Modified: incubator/ognl/trunk/src/main/java/org/apache/commons/ognl/OgnlParser.java
URL: http://svn.apache.org/viewvc/incubator/ognl/trunk/src/main/java/org/apache/commons/ognl/OgnlParser.java?rev=1103095&r1=1103094&r2=1103095&view=diff
==============================================================================
--- incubator/ognl/trunk/src/main/java/org/apache/commons/ognl/OgnlParser.java (original)
+++ incubator/ognl/trunk/src/main/java/org/apache/commons/ognl/OgnlParser.java Sat May 14 13:18:29 2011
@@ -21,3232 +21,4825 @@
package org.apache.commons.ognl;
/**
- * OgnlParser is a JavaCC parser class; it translates OGNL expressions into abstract
- * syntax trees (ASTs) that can then be interpreted by the getValue and setValue methods.
+ * OgnlParser is a JavaCC parser class; it translates OGNL expressions into abstract syntax trees (ASTs) that can then
+ * be interpreted by the getValue and setValue methods.
*/
-public class OgnlParser/*@bgen(jjtree)*/implements OgnlParserTreeConstants, OgnlParserConstants {/*@bgen(jjtree)*/
- protected JJTOgnlParserState jjtree = new JJTOgnlParserState();
+public class OgnlParser
+ /* @bgen(jjtree) */implements OgnlParserTreeConstants, OgnlParserConstants
+{/* @bgen(jjtree) */
+ protected JJTOgnlParserState jjtree = new JJTOgnlParserState();
+
+ /**
+ * This is the top-level construct of OGNL.
+ */
+ final public Node topLevelExpression()
+ throws ParseException
+ {
+ expression();
+ jj_consume_token( 0 );
+ {
+ if ( true )
+ return jjtree.rootNode();
+ }
+ throw new Error( "Missing return statement in function" );
+ }
-/**
- * This is the top-level construct of OGNL.
- */
- final public Node topLevelExpression() throws ParseException {
- expression();
- jj_consume_token(0);
- {if (true) return jjtree.rootNode();}
- throw new Error("Missing return statement in function");
- }
-
-// sequence (level 14)
- final public void expression() throws ParseException {
- assignmentExpression();
- label_1:
- while (true) {
- switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case 1:
- ;
- break;
- default:
- jj_la1[0] = jj_gen;
- break label_1;
- }
- jj_consume_token(1);
- ASTSequence jjtn001 = new ASTSequence(JJTSEQUENCE);
- boolean jjtc001 = true;
- jjtree.openNodeScope(jjtn001);
- try {
+ // sequence (level 14)
+ final public void expression()
+ throws ParseException
+ {
assignmentExpression();
- } catch (Throwable jjte001) {
- if (jjtc001) {
- jjtree.clearNodeScope(jjtn001);
- jjtc001 = false;
- } else {
- jjtree.popNode();
- }
- if (jjte001 instanceof RuntimeException) {
- {if (true) throw (RuntimeException)jjte001;}
- }
- if (jjte001 instanceof ParseException) {
- {if (true) throw (ParseException)jjte001;}
- }
- {if (true) throw (Error)jjte001;}
- } finally {
- if (jjtc001) {
- jjtree.closeNodeScope(jjtn001, 2);
- }
- }
- }
- }
-
-// assignment expression (level 13)
- final public void assignmentExpression() throws ParseException {
- conditionalTestExpression();
- switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case 2:
- jj_consume_token(2);
- ASTAssign jjtn001 = new ASTAssign(JJTASSIGN);
- boolean jjtc001 = true;
- jjtree.openNodeScope(jjtn001);
- try {
- assignmentExpression();
- } catch (Throwable jjte001) {
- if (jjtc001) {
- jjtree.clearNodeScope(jjtn001);
- jjtc001 = false;
- } else {
- jjtree.popNode();
- }
- if (jjte001 instanceof RuntimeException) {
- {if (true) throw (RuntimeException)jjte001;}
+ label_1: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 1:
+ ;
+ break;
+ default:
+ jj_la1[0] = jj_gen;
+ break label_1;
+ }
+ jj_consume_token( 1 );
+ ASTSequence jjtn001 = new ASTSequence( JJTSEQUENCE );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ assignmentExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ }
+ }
+
+ // assignment expression (level 13)
+ final public void assignmentExpression()
+ throws ParseException
+ {
+ conditionalTestExpression();
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 2:
+ jj_consume_token( 2 );
+ ASTAssign jjtn001 = new ASTAssign( JJTASSIGN );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ assignmentExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ break;
+ default:
+ jj_la1[1] = jj_gen;
+ ;
+ }
+ }
+
+ // conditional test (level 12)
+ final public void conditionalTestExpression()
+ throws ParseException
+ {
+ logicalOrExpression();
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 3:
+ jj_consume_token( 3 );
+ conditionalTestExpression();
+ jj_consume_token( 4 );
+ ASTTest jjtn001 = new ASTTest( JJTTEST );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ conditionalTestExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 3 );
+ }
+ }
+ break;
+ default:
+ jj_la1[2] = jj_gen;
+ ;
+ }
+ }
+
+ // logical or (||) (level 11)
+ final public void logicalOrExpression()
+ throws ParseException
+ {
+ logicalAndExpression();
+ label_2: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 5:
+ case 6:
+ ;
+ break;
+ default:
+ jj_la1[3] = jj_gen;
+ break label_2;
+ }
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 5:
+ jj_consume_token( 5 );
+ break;
+ case 6:
+ jj_consume_token( 6 );
+ break;
+ default:
+ jj_la1[4] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTOr jjtn001 = new ASTOr( JJTOR );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ logicalAndExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ }
+ }
+
+ // logical and (&&) (level 10)
+ final public void logicalAndExpression()
+ throws ParseException
+ {
+ inclusiveOrExpression();
+ label_3: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 7:
+ case 8:
+ ;
+ break;
+ default:
+ jj_la1[5] = jj_gen;
+ break label_3;
+ }
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 7:
+ jj_consume_token( 7 );
+ break;
+ case 8:
+ jj_consume_token( 8 );
+ break;
+ default:
+ jj_la1[6] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTAnd jjtn001 = new ASTAnd( JJTAND );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ inclusiveOrExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ }
+ }
+
+ // bitwise or non-short-circuiting or (|) (level 9)
+ final public void inclusiveOrExpression()
+ throws ParseException
+ {
+ exclusiveOrExpression();
+ label_4: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 9:
+ case 10:
+ ;
+ break;
+ default:
+ jj_la1[7] = jj_gen;
+ break label_4;
+ }
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 9:
+ jj_consume_token( 9 );
+ break;
+ case 10:
+ jj_consume_token( 10 );
+ break;
+ default:
+ jj_la1[8] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTBitOr jjtn001 = new ASTBitOr( JJTBITOR );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ exclusiveOrExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ }
+ }
+
+ // exclusive or (^) (level 8)
+ final public void exclusiveOrExpression()
+ throws ParseException
+ {
+ andExpression();
+ label_5: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 11:
+ case 12:
+ ;
+ break;
+ default:
+ jj_la1[9] = jj_gen;
+ break label_5;
+ }
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 11:
+ jj_consume_token( 11 );
+ break;
+ case 12:
+ jj_consume_token( 12 );
+ break;
+ default:
+ jj_la1[10] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTXor jjtn001 = new ASTXor( JJTXOR );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ andExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ }
+ }
+
+ // bitwise or non-short-circuiting and (&) (level 7)
+ final public void andExpression()
+ throws ParseException
+ {
+ equalityExpression();
+ label_6: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 13:
+ case 14:
+ ;
+ break;
+ default:
+ jj_la1[11] = jj_gen;
+ break label_6;
+ }
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 13:
+ jj_consume_token( 13 );
+ break;
+ case 14:
+ jj_consume_token( 14 );
+ break;
+ default:
+ jj_la1[12] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTBitAnd jjtn001 = new ASTBitAnd( JJTBITAND );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ equalityExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ }
+ }
+
+ // equality/inequality (==/!=) (level 6)
+ final public void equalityExpression()
+ throws ParseException
+ {
+ relationalExpression();
+ label_7: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 15:
+ case 16:
+ case 17:
+ case 18:
+ ;
+ break;
+ default:
+ jj_la1[13] = jj_gen;
+ break label_7;
+ }
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 15:
+ case 16:
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 15:
+ jj_consume_token( 15 );
+ break;
+ case 16:
+ jj_consume_token( 16 );
+ break;
+ default:
+ jj_la1[14] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTEq jjtn001 = new ASTEq( JJTEQ );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ relationalExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ break;
+ case 17:
+ case 18:
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 17:
+ jj_consume_token( 17 );
+ break;
+ case 18:
+ jj_consume_token( 18 );
+ break;
+ default:
+ jj_la1[15] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTNotEq jjtn002 = new ASTNotEq( JJTNOTEQ );
+ boolean jjtc002 = true;
+ jjtree.openNodeScope( jjtn002 );
+ try
+ {
+ relationalExpression();
+ }
+ catch ( Throwable jjte002 )
+ {
+ if ( jjtc002 )
+ {
+ jjtree.clearNodeScope( jjtn002 );
+ jjtc002 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte002 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte002;
+ }
+ }
+ if ( jjte002 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte002;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte002;
+ }
+ }
+ finally
+ {
+ if ( jjtc002 )
+ {
+ jjtree.closeNodeScope( jjtn002, 2 );
+ }
+ }
+ break;
+ default:
+ jj_la1[16] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ }
+ }
+
+ // boolean relational expressions (level 5)
+ final public void relationalExpression()
+ throws ParseException
+ {
+ shiftExpression();
+ label_8: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 19:
+ case 20:
+ case 21:
+ case 22:
+ case 23:
+ case 24:
+ case 25:
+ case 26:
+ case 27:
+ case 28:
+ ;
+ break;
+ default:
+ jj_la1[17] = jj_gen;
+ break label_8;
+ }
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 19:
+ case 20:
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 19:
+ jj_consume_token( 19 );
+ break;
+ case 20:
+ jj_consume_token( 20 );
+ break;
+ default:
+ jj_la1[18] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTLess jjtn001 = new ASTLess( JJTLESS );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ shiftExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ break;
+ case 21:
+ case 22:
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 21:
+ jj_consume_token( 21 );
+ break;
+ case 22:
+ jj_consume_token( 22 );
+ break;
+ default:
+ jj_la1[19] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTGreater jjtn002 = new ASTGreater( JJTGREATER );
+ boolean jjtc002 = true;
+ jjtree.openNodeScope( jjtn002 );
+ try
+ {
+ shiftExpression();
+ }
+ catch ( Throwable jjte002 )
+ {
+ if ( jjtc002 )
+ {
+ jjtree.clearNodeScope( jjtn002 );
+ jjtc002 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte002 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte002;
+ }
+ }
+ if ( jjte002 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte002;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte002;
+ }
+ }
+ finally
+ {
+ if ( jjtc002 )
+ {
+ jjtree.closeNodeScope( jjtn002, 2 );
+ }
+ }
+ break;
+ case 23:
+ case 24:
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 23:
+ jj_consume_token( 23 );
+ break;
+ case 24:
+ jj_consume_token( 24 );
+ break;
+ default:
+ jj_la1[20] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTLessEq jjtn003 = new ASTLessEq( JJTLESSEQ );
+ boolean jjtc003 = true;
+ jjtree.openNodeScope( jjtn003 );
+ try
+ {
+ shiftExpression();
+ }
+ catch ( Throwable jjte003 )
+ {
+ if ( jjtc003 )
+ {
+ jjtree.clearNodeScope( jjtn003 );
+ jjtc003 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte003 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte003;
+ }
+ }
+ if ( jjte003 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte003;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte003;
+ }
+ }
+ finally
+ {
+ if ( jjtc003 )
+ {
+ jjtree.closeNodeScope( jjtn003, 2 );
+ }
+ }
+ break;
+ case 25:
+ case 26:
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 25:
+ jj_consume_token( 25 );
+ break;
+ case 26:
+ jj_consume_token( 26 );
+ break;
+ default:
+ jj_la1[21] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTGreaterEq jjtn004 = new ASTGreaterEq( JJTGREATEREQ );
+ boolean jjtc004 = true;
+ jjtree.openNodeScope( jjtn004 );
+ try
+ {
+ shiftExpression();
+ }
+ catch ( Throwable jjte004 )
+ {
+ if ( jjtc004 )
+ {
+ jjtree.clearNodeScope( jjtn004 );
+ jjtc004 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte004 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte004;
+ }
+ }
+ if ( jjte004 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte004;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte004;
+ }
+ }
+ finally
+ {
+ if ( jjtc004 )
+ {
+ jjtree.closeNodeScope( jjtn004, 2 );
+ }
+ }
+ break;
+ case 27:
+ jj_consume_token( 27 );
+ ASTIn jjtn005 = new ASTIn( JJTIN );
+ boolean jjtc005 = true;
+ jjtree.openNodeScope( jjtn005 );
+ try
+ {
+ shiftExpression();
+ }
+ catch ( Throwable jjte005 )
+ {
+ if ( jjtc005 )
+ {
+ jjtree.clearNodeScope( jjtn005 );
+ jjtc005 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte005 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte005;
+ }
+ }
+ if ( jjte005 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte005;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte005;
+ }
+ }
+ finally
+ {
+ if ( jjtc005 )
+ {
+ jjtree.closeNodeScope( jjtn005, 2 );
+ }
+ }
+ break;
+ case 28:
+ jj_consume_token( 28 );
+ jj_consume_token( 27 );
+ ASTNotIn jjtn006 = new ASTNotIn( JJTNOTIN );
+ boolean jjtc006 = true;
+ jjtree.openNodeScope( jjtn006 );
+ try
+ {
+ shiftExpression();
+ }
+ catch ( Throwable jjte006 )
+ {
+ if ( jjtc006 )
+ {
+ jjtree.clearNodeScope( jjtn006 );
+ jjtc006 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte006 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte006;
+ }
+ }
+ if ( jjte006 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte006;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte006;
+ }
+ }
+ finally
+ {
+ if ( jjtc006 )
+ {
+ jjtree.closeNodeScope( jjtn006, 2 );
+ }
+ }
+ break;
+ default:
+ jj_la1[22] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ }
+ }
+
+ // bit shift expressions (level 4)
+ final public void shiftExpression()
+ throws ParseException
+ {
+ additiveExpression();
+ label_9: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 29:
+ case 30:
+ case 31:
+ case 32:
+ case 33:
+ case 34:
+ ;
+ break;
+ default:
+ jj_la1[23] = jj_gen;
+ break label_9;
+ }
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 29:
+ case 30:
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 29:
+ jj_consume_token( 29 );
+ break;
+ case 30:
+ jj_consume_token( 30 );
+ break;
+ default:
+ jj_la1[24] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTShiftLeft jjtn001 = new ASTShiftLeft( JJTSHIFTLEFT );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ additiveExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ break;
+ case 31:
+ case 32:
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 31:
+ jj_consume_token( 31 );
+ break;
+ case 32:
+ jj_consume_token( 32 );
+ break;
+ default:
+ jj_la1[25] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTShiftRight jjtn002 = new ASTShiftRight( JJTSHIFTRIGHT );
+ boolean jjtc002 = true;
+ jjtree.openNodeScope( jjtn002 );
+ try
+ {
+ additiveExpression();
+ }
+ catch ( Throwable jjte002 )
+ {
+ if ( jjtc002 )
+ {
+ jjtree.clearNodeScope( jjtn002 );
+ jjtc002 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte002 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte002;
+ }
+ }
+ if ( jjte002 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte002;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte002;
+ }
+ }
+ finally
+ {
+ if ( jjtc002 )
+ {
+ jjtree.closeNodeScope( jjtn002, 2 );
+ }
+ }
+ break;
+ case 33:
+ case 34:
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 33:
+ jj_consume_token( 33 );
+ break;
+ case 34:
+ jj_consume_token( 34 );
+ break;
+ default:
+ jj_la1[26] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTUnsignedShiftRight jjtn003 = new ASTUnsignedShiftRight( JJTUNSIGNEDSHIFTRIGHT );
+ boolean jjtc003 = true;
+ jjtree.openNodeScope( jjtn003 );
+ try
+ {
+ additiveExpression();
+ }
+ catch ( Throwable jjte003 )
+ {
+ if ( jjtc003 )
+ {
+ jjtree.clearNodeScope( jjtn003 );
+ jjtc003 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte003 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte003;
+ }
+ }
+ if ( jjte003 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte003;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte003;
+ }
+ }
+ finally
+ {
+ if ( jjtc003 )
+ {
+ jjtree.closeNodeScope( jjtn003, 2 );
+ }
+ }
+ break;
+ default:
+ jj_la1[27] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ }
+ }
+
+ // binary addition/subtraction (level 3)
+ final public void additiveExpression()
+ throws ParseException
+ {
+ multiplicativeExpression();
+ label_10: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 35:
+ case 36:
+ ;
+ break;
+ default:
+ jj_la1[28] = jj_gen;
+ break label_10;
+ }
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 35:
+ jj_consume_token( 35 );
+ ASTAdd jjtn001 = new ASTAdd( JJTADD );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ multiplicativeExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ break;
+ case 36:
+ jj_consume_token( 36 );
+ ASTSubtract jjtn002 = new ASTSubtract( JJTSUBTRACT );
+ boolean jjtc002 = true;
+ jjtree.openNodeScope( jjtn002 );
+ try
+ {
+ multiplicativeExpression();
+ }
+ catch ( Throwable jjte002 )
+ {
+ if ( jjtc002 )
+ {
+ jjtree.clearNodeScope( jjtn002 );
+ jjtc002 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte002 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte002;
+ }
+ }
+ if ( jjte002 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte002;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte002;
+ }
+ }
+ finally
+ {
+ if ( jjtc002 )
+ {
+ jjtree.closeNodeScope( jjtn002, 2 );
+ }
+ }
+ break;
+ default:
+ jj_la1[29] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ }
+ }
+
+ // multiplication/division/remainder (level 2)
+ final public void multiplicativeExpression()
+ throws ParseException
+ {
+ unaryExpression();
+ label_11: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 37:
+ case 38:
+ case 39:
+ ;
+ break;
+ default:
+ jj_la1[30] = jj_gen;
+ break label_11;
+ }
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 37:
+ jj_consume_token( 37 );
+ ASTMultiply jjtn001 = new ASTMultiply( JJTMULTIPLY );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ unaryExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ break;
+ case 38:
+ jj_consume_token( 38 );
+ ASTDivide jjtn002 = new ASTDivide( JJTDIVIDE );
+ boolean jjtc002 = true;
+ jjtree.openNodeScope( jjtn002 );
+ try
+ {
+ unaryExpression();
+ }
+ catch ( Throwable jjte002 )
+ {
+ if ( jjtc002 )
+ {
+ jjtree.clearNodeScope( jjtn002 );
+ jjtc002 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte002 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte002;
+ }
+ }
+ if ( jjte002 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte002;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte002;
+ }
+ }
+ finally
+ {
+ if ( jjtc002 )
+ {
+ jjtree.closeNodeScope( jjtn002, 2 );
+ }
+ }
+ break;
+ case 39:
+ jj_consume_token( 39 );
+ ASTRemainder jjtn003 = new ASTRemainder( JJTREMAINDER );
+ boolean jjtc003 = true;
+ jjtree.openNodeScope( jjtn003 );
+ try
+ {
+ unaryExpression();
+ }
+ catch ( Throwable jjte003 )
+ {
+ if ( jjtc003 )
+ {
+ jjtree.clearNodeScope( jjtn003 );
+ jjtc003 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte003 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte003;
+ }
+ }
+ if ( jjte003 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte003;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte003;
+ }
+ }
+ finally
+ {
+ if ( jjtc003 )
+ {
+ jjtree.closeNodeScope( jjtn003, 2 );
+ }
+ }
+ break;
+ default:
+ jj_la1[31] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ }
+ }
+
+ // unary (level 1)
+ final public void unaryExpression()
+ throws ParseException
+ {
+ StringBuffer sb;
+ Token t;
+ ASTInstanceof ionode;
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 36:
+ jj_consume_token( 36 );
+ ASTNegate jjtn001 = new ASTNegate( JJTNEGATE );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ unaryExpression();
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 1 );
+ }
+ }
+ break;
+ case 35:
+ jj_consume_token( 35 );
+ unaryExpression();
+ break;
+ case 40:
+ jj_consume_token( 40 );
+ ASTBitNegate jjtn002 = new ASTBitNegate( JJTBITNEGATE );
+ boolean jjtc002 = true;
+ jjtree.openNodeScope( jjtn002 );
+ try
+ {
+ unaryExpression();
+ }
+ catch ( Throwable jjte002 )
+ {
+ if ( jjtc002 )
+ {
+ jjtree.clearNodeScope( jjtn002 );
+ jjtc002 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte002 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte002;
+ }
+ }
+ if ( jjte002 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte002;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte002;
+ }
+ }
+ finally
+ {
+ if ( jjtc002 )
+ {
+ jjtree.closeNodeScope( jjtn002, 1 );
+ }
+ }
+ break;
+ case 28:
+ case 41:
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 41:
+ jj_consume_token( 41 );
+ break;
+ case 28:
+ jj_consume_token( 28 );
+ break;
+ default:
+ jj_la1[32] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTNot jjtn003 = new ASTNot( JJTNOT );
+ boolean jjtc003 = true;
+ jjtree.openNodeScope( jjtn003 );
+ try
+ {
+ unaryExpression();
+ }
+ catch ( Throwable jjte003 )
+ {
+ if ( jjtc003 )
+ {
+ jjtree.clearNodeScope( jjtn003 );
+ jjtc003 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte003 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte003;
+ }
+ }
+ if ( jjte003 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte003;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte003;
+ }
+ }
+ finally
+ {
+ if ( jjtc003 )
+ {
+ jjtree.closeNodeScope( jjtn003, 1 );
+ }
+ }
+ break;
+ case 4:
+ case 44:
+ case 46:
+ case 47:
+ case 48:
+ case 49:
+ case 50:
+ case 51:
+ case 52:
+ case 54:
+ case 56:
+ case 57:
+ case IDENT:
+ case DYNAMIC_SUBSCRIPT:
+ case CHAR_LITERAL:
+ case BACK_CHAR_LITERAL:
+ case STRING_LITERAL:
+ case INT_LITERAL:
+ case FLT_LITERAL:
+ navigationChain();
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 42:
+ jj_consume_token( 42 );
+ t = jj_consume_token( IDENT );
+ ASTInstanceof jjtn004 = new ASTInstanceof( JJTINSTANCEOF );
+ boolean jjtc004 = true;
+ jjtree.openNodeScope( jjtn004 );
+ try
+ {
+ jjtree.closeNodeScope( jjtn004, 1 );
+ jjtc004 = false;
+ sb = new StringBuffer( t.image );
+ ionode = jjtn004;
+ }
+ finally
+ {
+ if ( jjtc004 )
+ {
+ jjtree.closeNodeScope( jjtn004, 1 );
+ }
+ }
+ label_12: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 43:
+ ;
+ break;
+ default:
+ jj_la1[33] = jj_gen;
+ break label_12;
+ }
+ jj_consume_token( 43 );
+ t = jj_consume_token( IDENT );
+ sb.append( '.' ).append( t.image );
+ }
+ ionode.setTargetType( new String( sb ) );
+ break;
+ default:
+ jj_la1[34] = jj_gen;
+ ;
+ }
+ break;
+ default:
+ jj_la1[35] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ }
+
+ // navigation chain: property references, method calls, projections, selections, etc.
+ final public void navigationChain()
+ throws ParseException
+ {
+ primaryExpression();
+ label_13: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 43:
+ case 44:
+ case 52:
+ case DYNAMIC_SUBSCRIPT:
+ ;
+ break;
+ default:
+ jj_la1[36] = jj_gen;
+ break label_13;
+ }
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 43:
+ jj_consume_token( 43 );
+ ASTChain jjtn001 = new ASTChain( JJTCHAIN );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case IDENT:
+ if ( jj_2_1( 2 ) )
+ {
+ methodCall();
+ }
+ else
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case IDENT:
+ propertyName();
+ break;
+ default:
+ jj_la1[37] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ }
+ break;
+ case 54:
+ if ( jj_2_2( 2 ) )
+ {
+ projection();
+ }
+ else
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 54:
+ selection();
+ break;
+ default:
+ jj_la1[38] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ }
+ break;
+ case 44:
+ jj_consume_token( 44 );
+ expression();
+ jj_consume_token( 45 );
+ break;
+ default:
+ jj_la1[39] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ }
+ catch ( Throwable jjte001 )
+ {
+ if ( jjtc001 )
+ {
+ jjtree.clearNodeScope( jjtn001 );
+ jjtc001 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte001 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte001;
+ }
+ }
+ if ( jjte001 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte001;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte001;
+ }
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 2 );
+ }
+ }
+ break;
+ case 52:
+ case DYNAMIC_SUBSCRIPT:
+ ASTChain jjtn002 = new ASTChain( JJTCHAIN );
+ boolean jjtc002 = true;
+ jjtree.openNodeScope( jjtn002 );
+ try
+ {
+ index();
+ }
+ catch ( Throwable jjte002 )
+ {
+ if ( jjtc002 )
+ {
+ jjtree.clearNodeScope( jjtn002 );
+ jjtc002 = false;
+ }
+ else
+ {
+ jjtree.popNode();
+ }
+ if ( jjte002 instanceof RuntimeException )
+ {
+ {
+ if ( true )
+ throw (RuntimeException) jjte002;
+ }
+ }
+ if ( jjte002 instanceof ParseException )
+ {
+ {
+ if ( true )
+ throw (ParseException) jjte002;
+ }
+ }
+ {
+ if ( true )
+ throw (Error) jjte002;
+ }
+ }
+ finally
+ {
+ if ( jjtc002 )
+ {
+ jjtree.closeNodeScope( jjtn002, 2 );
+ }
+ }
+ break;
+ case 44:
+ jj_consume_token( 44 );
+ expression();
+ ASTEval jjtn003 = new ASTEval( JJTEVAL );
+ boolean jjtc003 = true;
+ jjtree.openNodeScope( jjtn003 );
+ try
+ {
+ jj_consume_token( 45 );
+ }
+ finally
+ {
+ if ( jjtc003 )
+ {
+ jjtree.closeNodeScope( jjtn003, 2 );
+ }
+ }
+ break;
+ default:
+ jj_la1[40] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ }
+ }
+
+ final public void primaryExpression()
+ throws ParseException
+ {
+ Token t;
+ String className = null;
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case CHAR_LITERAL:
+ case BACK_CHAR_LITERAL:
+ case STRING_LITERAL:
+ case INT_LITERAL:
+ case FLT_LITERAL:
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case CHAR_LITERAL:
+ jj_consume_token( CHAR_LITERAL );
+ break;
+ case BACK_CHAR_LITERAL:
+ jj_consume_token( BACK_CHAR_LITERAL );
+ break;
+ case STRING_LITERAL:
+ jj_consume_token( STRING_LITERAL );
+ break;
+ case INT_LITERAL:
+ jj_consume_token( INT_LITERAL );
+ break;
+ case FLT_LITERAL:
+ jj_consume_token( FLT_LITERAL );
+ break;
+ default:
+ jj_la1[41] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
+ ASTConst jjtn001 = new ASTConst( JJTCONST );
+ boolean jjtc001 = true;
+ jjtree.openNodeScope( jjtn001 );
+ try
+ {
+ jjtree.closeNodeScope( jjtn001, 0 );
+ jjtc001 = false;
+ jjtn001.setValue( token_source.literalValue );
+ }
+ finally
+ {
+ if ( jjtc001 )
+ {
+ jjtree.closeNodeScope( jjtn001, 0 );
+ }
+ }
+ break;
+ case 46:
+ jj_consume_token( 46 );
+ ASTConst jjtn002 = new ASTConst( JJTCONST );
+ boolean jjtc002 = true;
+ jjtree.openNodeScope( jjtn002 );
+ try
+ {
+ jjtree.closeNodeScope( jjtn002, 0 );
+ jjtc002 = false;
+ jjtn002.setValue( Boolean.TRUE );
+ }
+ finally
+ {
+ if ( jjtc002 )
+ {
+ jjtree.closeNodeScope( jjtn002, 0 );
+ }
+ }
+ break;
+ case 47:
+ jj_consume_token( 47 );
+ ASTConst jjtn003 = new ASTConst( JJTCONST );
+ boolean jjtc003 = true;
+ jjtree.openNodeScope( jjtn003 );
+ try
+ {
+ jjtree.closeNodeScope( jjtn003, 0 );
+ jjtc003 = false;
+ jjtn003.setValue( Boolean.FALSE );
+ }
+ finally
+ {
+ if ( jjtc003 )
+ {
+ jjtree.closeNodeScope( jjtn003, 0 );
+ }
+ }
+ break;
+ case 48:
+ ASTConst jjtn004 = new ASTConst( JJTCONST );
+ boolean jjtc004 = true;
+ jjtree.openNodeScope( jjtn004 );
+ try
+ {
+ jj_consume_token( 48 );
+ }
+ finally
+ {
+ if ( jjtc004 )
+ {
+ jjtree.closeNodeScope( jjtn004, 0 );
+ }
+ }
+ break;
+ default:
+ jj_la1[48] = jj_gen;
+ if ( jj_2_4( 2 ) )
+ {
+ jj_consume_token( 49 );
+ ASTThisVarRef jjtn005 = new ASTThisVarRef( JJTTHISVARREF );
+ boolean jjtc005 = true;
+ jjtree.openNodeScope( jjtn005 );
+ try
+ {
+ jjtree.closeNodeScope( jjtn005, 0 );
+ jjtc005 = false;
+ jjtn005.setName( "this" );
+ }
+ finally
+ {
+ if ( jjtc005 )
+ {
+ jjtree.closeNodeScope( jjtn005, 0 );
+ }
+ }
+ }
+ else if ( jj_2_5( 2 ) )
+ {
+ jj_consume_token( 50 );
+ ASTRootVarRef jjtn006 = new ASTRootVarRef( JJTROOTVARREF );
+ boolean jjtc006 = true;
+ jjtree.openNodeScope( jjtn006 );
+ try
+ {
+ jjtree.closeNodeScope( jjtn006, 0 );
+ jjtc006 = false;
+ jjtn006.setName( "root" );
+ }
+ finally
+ {
+ if ( jjtc006 )
+ {
+ jjtree.closeNodeScope( jjtn006, 0 );
+ }
+ }
+ }
+ else if ( jj_2_6( 2 ) )
+ {
+ jj_consume_token( 51 );
+ t = jj_consume_token( IDENT );
+ ASTVarRef jjtn007 = new ASTVarRef( JJTVARREF );
+ boolean jjtc007 = true;
+ jjtree.openNodeScope( jjtn007 );
+ try
+ {
+ jjtree.closeNodeScope( jjtn007, 0 );
+ jjtc007 = false;
+ jjtn007.setName( t.image );
+ }
+ finally
+ {
+ if ( jjtc007 )
+ {
+ jjtree.closeNodeScope( jjtn007, 0 );
+ }
+ }
+ }
+ else if ( jj_2_7( 2 ) )
+ {
+ jj_consume_token( 4 );
+ jj_consume_token( 52 );
+ expression();
+ jj_consume_token( 53 );
+ ASTConst jjtn008 = new ASTConst( JJTCONST );
+ boolean jjtc008 = true;
+ jjtree.openNodeScope( jjtn008 );
+ try
+ {
+ jjtree.closeNodeScope( jjtn008, 1 );
+ jjtc008 = false;
+ jjtn008.setValue( jjtn008.jjtGetChild( 0 ) );
+ }
+ finally
+ {
+ if ( jjtc008 )
+ {
+ jjtree.closeNodeScope( jjtn008, 1 );
+ }
+ }
+ }
+ else
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 56:
+ staticReference();
+ break;
+ default:
+ jj_la1[49] = jj_gen;
+ if ( jj_2_8( 2 ) )
+ {
+ constructorCall();
+ }
+ else
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case IDENT:
+ if ( jj_2_3( 2 ) )
+ {
+ methodCall();
}
- if (jjte001 instanceof ParseException) {
- {if (true) throw (ParseException)jjte001;}
+ else
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case IDENT:
+ propertyName();
+ break;
+ default:
+ jj_la1[42] = jj_gen;
+ jj_consume_token( -1 );
+ throw new ParseException();
+ }
}
- {if (true) throw (Error)jjte001;}
- } finally {
- if (jjtc001) {
- jjtree.closeNodeScope(jjtn001, 2);
+ break;
+ case 52:
+ case DYNAMIC_SUBSCRIPT:
+ index();
+ break;
+ case 44:
+ jj_consume_token( 44 );
+ expression();
+ jj_consume_token( 45 );
+ break;
+ case 54:
+ jj_consume_token( 54 );
+ ASTList jjtn009 = new ASTList( JJTLIST );
+ boolean jjtc009 = true;
+ jjtree.openNodeScope( jjtn009 );
+ try
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 4:
+ case 28:
+ case 35:
+ case 36:
+ case 40:
+ case 41:
+ case 44:
+ case 46:
+ case 47:
+ case 48:
+ case 49:
+ case 50:
+ case 51:
+ case 52:
+ case 54:
+ case 56:
+ case 57:
+ case IDENT:
+ case DYNAMIC_SUBSCRIPT:
+ case CHAR_LITERAL:
+ case BACK_CHAR_LITERAL:
+ case STRING_LITERAL:
+ case INT_LITERAL:
+ case FLT_LITERAL:
+ assignmentExpression();
+ label_14: while ( true )
+ {
+ switch ( ( jj_ntk == -1 ) ? jj_ntk() : jj_ntk )
+ {
+ case 1:
+ ;
+ break;
+ default:
+ jj_la1[43] = jj_gen;
+ break label_14;
+ }
+ jj_consume_token( 1 );
+ assignmentExpression();
+ }
+ break;
+ default:
+ jj_la1[44] = jj_gen;
+ ;
+ }
}
- }
- break;
- default:
- jj_la1[1] = jj_gen;
- ;
- }
- }
-
-// conditional test (level 12)
- final public void conditionalTestExpression() throws ParseException {
- logicalOrExpression();
- switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case 3:
- jj_consume_token(3);
- conditionalTestExpression();
- jj_consume_token(4);
- ASTTest jjtn001 = new ASTTest(JJTTEST);
- boolean jjtc001 = true;
- jjtree.openNodeScope(jjtn001);
- try {
- conditionalTestExpression();
- } catch (Throwable jjte001) {
- if (jjtc001) {
- jjtree.clearNodeScope(jjtn001);
- jjtc001 = false;
- } else {
- jjtree.popNode();
+ catch ( Throwable jjte009 )
+ {
[... 5558 lines stripped ...]