Example #1
0
 /*
  * Boolean
  * For 'true' 'false'
  */
 public final void Boolean() throws ParseException {
   switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
     case TRUE:
       AstTrue jjtn001 = new AstTrue(JJTTRUE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001);
       try {
         jj_consume_token(TRUE);
       } finally {
         if (jjtc001) {
           jjtree.closeNodeScope(jjtn001, true);
         }
       }
       break;
     case FALSE:
       AstFalse jjtn002 = new AstFalse(JJTFALSE);
       boolean jjtc002 = true;
       jjtree.openNodeScope(jjtn002);
       try {
         jj_consume_token(FALSE);
       } finally {
         if (jjtc002) {
           jjtree.closeNodeScope(jjtn002, true);
         }
       }
       break;
     default:
       jj_la1[34] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
   }
 }
Example #2
0
 /*
  * BracketSuffix
  * Sub Expression Suffix
  */
 public final void BracketSuffix() throws ParseException {
   /*@bgen(jjtree) BracketSuffix */
   AstBracketSuffix jjtn000 = new AstBracketSuffix(JJTBRACKETSUFFIX);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   try {
     jj_consume_token(LBRACK);
     Expression();
     jj_consume_token(RBRACK);
   } 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);
     }
   }
 }
Example #3
0
 /*
  * DynamicExpression
  * ${..} Expressions
  */
 public final void DynamicExpression() throws ParseException {
   /*@bgen(jjtree) DynamicExpression */
   AstDynamicExpression jjtn000 = new AstDynamicExpression(JJTDYNAMICEXPRESSION);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   try {
     jj_consume_token(START_DYNAMIC_EXPRESSION);
     Expression();
     jj_consume_token(END_EXPRESSION);
   } 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);
     }
   }
 }
Example #4
0
 /*
  * LiteralExpression
  * Non-EL Expression blocks
  */
 public final void LiteralExpression() throws ParseException {
   /*@bgen(jjtree) LiteralExpression */
   AstLiteralExpression jjtn000 = new AstLiteralExpression(JJTLITERALEXPRESSION);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   Token t = null;
   try {
     t = jj_consume_token(LITERAL_EXPRESSION);
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
     jjtn000.setImage(t.image);
   } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
   }
 }
Example #5
0
 /*
  * String
  * For Quoted Literals
  */
 public final void String() throws ParseException {
   /*@bgen(jjtree) String */
   AstString jjtn000 = new AstString(JJTSTRING);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   Token t = null;
   try {
     t = jj_consume_token(STRING_LITERAL);
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
     jjtn000.setImage(t.image);
   } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
   }
 }
Example #6
0
 /*
  * Integer
  * For Simple Numeric Literals
  */
 public final void Integer() throws ParseException {
   /*@bgen(jjtree) Integer */
   AstInteger jjtn000 = new AstInteger(JJTINTEGER);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   Token t = null;
   try {
     t = jj_consume_token(INTEGER_LITERAL);
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
     jjtn000.setImage(t.image);
   } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
   }
 }
Example #7
0
 /*
  * FloatinPoint
  * For Decimal and Floating Point Literals
  */
 public final void FloatingPoint() throws ParseException {
   /*@bgen(jjtree) FloatingPoint */
   AstFloatingPoint jjtn000 = new AstFloatingPoint(JJTFLOATINGPOINT);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   Token t = null;
   try {
     t = jj_consume_token(FLOATING_POINT_LITERAL);
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
     jjtn000.setImage(t.image);
   } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
   }
 }
Example #8
0
 /*
  * DotSuffix
  * Dot Property
  */
 public final void DotSuffix() throws ParseException {
   /*@bgen(jjtree) DotSuffix */
   AstDotSuffix jjtn000 = new AstDotSuffix(JJTDOTSUFFIX);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   Token t = null;
   try {
     jj_consume_token(DOT);
     t = jj_consume_token(IDENTIFIER);
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
     jjtn000.setImage(t.image);
   } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
   }
 }
Example #9
0
 /*
  * And
  * For 'and' '&&', then Equality
  */
 public final void And() throws ParseException {
   Equality();
   label_4:
   while (true) {
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case AND0:
       case AND1:;
         break;
       default:
         jj_la1[5] = jj_gen;
         break label_4;
     }
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case AND0:
         jj_consume_token(AND0);
         break;
       case AND1:
         jj_consume_token(AND1);
         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 {
       Equality();
     } 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);
       }
     }
   }
 }
Example #10
0
 /*
  * Or
  * For 'or' '||', then And
  */
 public final void Or() throws ParseException {
   And();
   label_3:
   while (true) {
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case OR0:
       case OR1:;
         break;
       default:
         jj_la1[3] = jj_gen;
         break label_3;
     }
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case OR0:
         jj_consume_token(OR0);
         break;
       case OR1:
         jj_consume_token(OR1);
         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 {
       And();
     } 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);
       }
     }
   }
 }
Example #11
0
 /*
  * Null
  * For 'null'
  */
 public final void Null() throws ParseException {
   /*@bgen(jjtree) Null */
   AstNull jjtn000 = new AstNull(JJTNULL);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   try {
     jj_consume_token(NULL);
   } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
   }
 }
Example #12
0
 /*
  * Choice
  * For Choice markup a ? b : c, then Or
  */
 public final void Choice() throws ParseException {
   Or();
   label_2:
   while (true) {
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case QUESTIONMARK:;
         break;
       default:
         jj_la1[2] = jj_gen;
         break label_2;
     }
     jj_consume_token(QUESTIONMARK);
     Or();
     jj_consume_token(COLON);
     AstChoice jjtn001 = new AstChoice(JJTCHOICE);
     boolean jjtc001 = true;
     jjtree.openNodeScope(jjtn001);
     try {
       Choice();
     } 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);
       }
     }
   }
 }
Example #13
0
 /*
  * Value
  * Defines Prefix plus zero or more Suffixes
  */
 public final void Value() throws ParseException {
   AstValue jjtn001 = new AstValue(JJTVALUE);
   boolean jjtc001 = true;
   jjtree.openNodeScope(jjtn001);
   try {
     ValuePrefix();
     label_9:
     while (true) {
       switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
         case DOT:
         case LBRACK:;
           break;
         default:
           jj_la1[25] = jj_gen;
           break label_9;
       }
       ValueSuffix();
     }
   } 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, jjtree.nodeArity() > 1);
     }
   }
 }
Example #14
0
 /*
  * Unary
  * For '-' '!' 'not' 'empty', then Value
  */
 public final void Unary() throws ParseException {
   switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
     case MINUS:
       jj_consume_token(MINUS);
       AstNegative jjtn001 = new AstNegative(JJTNEGATIVE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001);
       try {
         Unary();
       } 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, true);
         }
       }
       break;
     case NOT0:
     case NOT1:
       switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
         case NOT0:
           jj_consume_token(NOT0);
           break;
         case NOT1:
           jj_consume_token(NOT1);
           break;
         default:
           jj_la1[23] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
       }
       AstNot jjtn002 = new AstNot(JJTNOT);
       boolean jjtc002 = true;
       jjtree.openNodeScope(jjtn002);
       try {
         Unary();
       } 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, true);
         }
       }
       break;
     case EMPTY:
       jj_consume_token(EMPTY);
       AstEmpty jjtn003 = new AstEmpty(JJTEMPTY);
       boolean jjtc003 = true;
       jjtree.openNodeScope(jjtn003);
       try {
         Unary();
       } 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, true);
         }
       }
       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[24] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
   }
 }
Example #15
0
 /*
  * Multiplication
  * For a bunch of them, then Unary
  */
 public final void Multiplication() throws ParseException {
   Unary();
   label_8:
   while (true) {
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case MULT:
       case DIV0:
       case DIV1:
       case MOD0:
       case MOD1:;
         break;
       default:
         jj_la1[19] = jj_gen;
         break label_8;
     }
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case MULT:
         jj_consume_token(MULT);
         AstMult jjtn001 = new AstMult(JJTMULT);
         boolean jjtc001 = true;
         jjtree.openNodeScope(jjtn001);
         try {
           Unary();
         } 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 DIV0:
       case DIV1:
         switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
           case DIV0:
             jj_consume_token(DIV0);
             break;
           case DIV1:
             jj_consume_token(DIV1);
             break;
           default:
             jj_la1[20] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
         }
         AstDiv jjtn002 = new AstDiv(JJTDIV);
         boolean jjtc002 = true;
         jjtree.openNodeScope(jjtn002);
         try {
           Unary();
         } 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 MOD0:
       case MOD1:
         switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
           case MOD0:
             jj_consume_token(MOD0);
             break;
           case MOD1:
             jj_consume_token(MOD1);
             break;
           default:
             jj_la1[21] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
         }
         AstMod jjtn003 = new AstMod(JJTMOD);
         boolean jjtc003 = true;
         jjtree.openNodeScope(jjtn003);
         try {
           Unary();
         } 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[22] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
     }
   }
 }
Example #16
0
 /*
  * Math
  * For '+' '-', then Multiplication
  */
 public final void Math() throws ParseException {
   Multiplication();
   label_7:
   while (true) {
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case PLUS:
       case MINUS:;
         break;
       default:
         jj_la1[17] = jj_gen;
         break label_7;
     }
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case PLUS:
         jj_consume_token(PLUS);
         AstPlus jjtn001 = new AstPlus(JJTPLUS);
         boolean jjtc001 = true;
         jjtree.openNodeScope(jjtn001);
         try {
           Multiplication();
         } 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 MINUS:
         jj_consume_token(MINUS);
         AstMinus jjtn002 = new AstMinus(JJTMINUS);
         boolean jjtc002 = true;
         jjtree.openNodeScope(jjtn002);
         try {
           Multiplication();
         } 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[18] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
     }
   }
 }
Example #17
0
 /*
  * Compare
  * For a bunch of them, then Math
  */
 public final void Compare() throws ParseException {
   Math();
   label_6:
   while (true) {
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case GT0:
       case GT1:
       case LT0:
       case LT1:
       case GE0:
       case GE1:
       case LE0:
       case LE1:;
         break;
       default:
         jj_la1[11] = jj_gen;
         break label_6;
     }
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case LT0:
       case LT1:
         switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
           case LT0:
             jj_consume_token(LT0);
             break;
           case LT1:
             jj_consume_token(LT1);
             break;
           default:
             jj_la1[12] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
         }
         AstLessThan jjtn001 = new AstLessThan(JJTLESSTHAN);
         boolean jjtc001 = true;
         jjtree.openNodeScope(jjtn001);
         try {
           Math();
         } 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 GT0:
       case GT1:
         switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
           case GT0:
             jj_consume_token(GT0);
             break;
           case GT1:
             jj_consume_token(GT1);
             break;
           default:
             jj_la1[13] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
         }
         AstGreaterThan jjtn002 = new AstGreaterThan(JJTGREATERTHAN);
         boolean jjtc002 = true;
         jjtree.openNodeScope(jjtn002);
         try {
           Math();
         } 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 LE0:
       case LE1:
         switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
           case LE0:
             jj_consume_token(LE0);
             break;
           case LE1:
             jj_consume_token(LE1);
             break;
           default:
             jj_la1[14] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
         }
         AstLessThanEqual jjtn003 = new AstLessThanEqual(JJTLESSTHANEQUAL);
         boolean jjtc003 = true;
         jjtree.openNodeScope(jjtn003);
         try {
           Math();
         } 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 GE0:
       case GE1:
         switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
           case GE0:
             jj_consume_token(GE0);
             break;
           case GE1:
             jj_consume_token(GE1);
             break;
           default:
             jj_la1[15] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
         }
         AstGreaterThanEqual jjtn004 = new AstGreaterThanEqual(JJTGREATERTHANEQUAL);
         boolean jjtc004 = true;
         jjtree.openNodeScope(jjtn004);
         try {
           Math();
         } 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;
       default:
         jj_la1[16] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
     }
   }
 }
Example #18
0
 /*
  * Equality
  * For '==' 'eq' '!=' 'ne', then Compare
  */
 public final void Equality() throws ParseException {
   Compare();
   label_5:
   while (true) {
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case EQ0:
       case EQ1:
       case NE0:
       case NE1:;
         break;
       default:
         jj_la1[7] = jj_gen;
         break label_5;
     }
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case EQ0:
       case EQ1:
         switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
           case EQ0:
             jj_consume_token(EQ0);
             break;
           case EQ1:
             jj_consume_token(EQ1);
             break;
           default:
             jj_la1[8] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
         }
         AstEqual jjtn001 = new AstEqual(JJTEQUAL);
         boolean jjtc001 = true;
         jjtree.openNodeScope(jjtn001);
         try {
           Compare();
         } 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 NE0:
       case NE1:
         switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
           case NE0:
             jj_consume_token(NE0);
             break;
           case NE1:
             jj_consume_token(NE1);
             break;
           default:
             jj_la1[9] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
         }
         AstNotEqual jjtn002 = new AstNotEqual(JJTNOTEQUAL);
         boolean jjtc002 = true;
         jjtree.openNodeScope(jjtn002);
         try {
           Compare();
         } 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[10] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
     }
   }
 }
Example #19
0
 /*
  * CompositeExpression
  * Allow most flexible parsing, restrict by examining
  * type of returned node
  */
 public final AstCompositeExpression CompositeExpression() throws ParseException {
   /*@bgen(jjtree) CompositeExpression */
   AstCompositeExpression jjtn000 = new AstCompositeExpression(JJTCOMPOSITEEXPRESSION);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   try {
     label_1:
     while (true) {
       switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
         case LITERAL_EXPRESSION:
         case START_DYNAMIC_EXPRESSION:
         case START_DEFERRED_EXPRESSION:;
           break;
         default:
           jj_la1[0] = jj_gen;
           break label_1;
       }
       switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
         case START_DEFERRED_EXPRESSION:
           DeferredExpression();
           break;
         case START_DYNAMIC_EXPRESSION:
           DynamicExpression();
           break;
         case LITERAL_EXPRESSION:
           LiteralExpression();
           break;
         default:
           jj_la1[1] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
       }
     }
     jj_consume_token(0);
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
     {
       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);
     }
   }
   throw new Error("Missing return statement in function");
 }
Example #20
0
 /*
  * Function
  * Namespace:Name(a,b,c)
  */
 public final void Function() throws ParseException {
   /*@bgen(jjtree) Function */
   AstFunction jjtn000 = new AstFunction(JJTFUNCTION);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   Token t0 = null;
   Token t1 = null;
   try {
     t0 = jj_consume_token(IDENTIFIER);
     switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
       case FUNCTIONSUFFIX:
         t1 = jj_consume_token(FUNCTIONSUFFIX);
         break;
       default:
         jj_la1[30] = jj_gen;
         ;
     }
     if (t1 != null) {
       jjtn000.setPrefix(t0.image);
       jjtn000.setLocalName(t1.image.substring(1));
     } else {
       jjtn000.setLocalName(t0.image);
     }
     jj_consume_token(LPAREN);
     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 NOT0:
       case NOT1:
       case EMPTY:
       case MINUS:
       case IDENTIFIER:
         Expression();
         label_10:
         while (true) {
           switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
             case COMMA:;
               break;
             default:
               jj_la1[31] = jj_gen;
               break label_10;
           }
           jj_consume_token(COMMA);
           Expression();
         }
         break;
       default:
         jj_la1[32] = jj_gen;
         ;
     }
     jj_consume_token(RPAREN);
   } 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);
     }
   }
 }