Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /* Generated By:JJTree&JavaCC: Do not edit this line. ELParser.java */
   package org.apache.el.parser;
   import java.io.StringReader;
   
   import javax.el.ELException;
   
   @SuppressWarnings("all"// Ignore warnings in generated code
   public class ELParser/*@bgen(jjtree)*/implements ELParserTreeConstantsELParserConstants {/*@bgen(jjtree)*/
     protected JJTELParserState jjtree = new JJTELParserState();public static Node parse(String refthrows ELException
      {
          try {
              return (new ELParser(new StringReader(ref))).CompositeExpression();
          } catch (ParseException pe) {
              throw new ELException(pe.getMessage());
          }
      }
  
  /*
   * CompositeExpression
   * Allow most flexible parsing, restrict by examining
   * type of returned node
   */
    final public AstCompositeExpression CompositeExpression() throws ParseException {
                                                                       /*@bgen(jjtree) CompositeExpression */
    boolean jjtc000 = true;
    .openNodeScope(jjtn000);
      try {
        label_1:
        while (true) {
          switch ((==-1)?jj_ntk():) {
          case :
          case :
          case :
            ;
            break;
          default:
            [0] = ;
            break label_1;
          }
          switch ((==-1)?jj_ntk():) {
          case :
            DeferredExpression();
            break;
          case :
            DynamicExpression();
            break;
          case :
            LiteralExpression();
            break;
          default:
            [1] = ;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
        jj_consume_token(0);
                                                                                  .closeNodeScope(jjtn000true);
                                                                                  jjtc000 = false;
                                                                                  {if (truereturn jjtn000;}
      } catch (Throwable jjte000) {
        if (jjtc000) {
          .clearNodeScope(jjtn000);
          jjtc000 = false;
        } else {
          .popNode();
        }
        if (jjte000 instanceof RuntimeException) {
          {if (truethrow (RuntimeException)jjte000;}
        }
        if (jjte000 instanceof ParseException) {
          {if (truethrow (ParseException)jjte000;}
        }
        {if (truethrow (Error)jjte000;}
      } finally {
        if (jjtc000) {
          .closeNodeScope(jjtn000true);
        }
      }
      throw new Error("Missing return statement in function");
    }
  
  /*
   * LiteralExpression
   * Non-EL Expression blocks
   */
    final public void LiteralExpression() throws ParseException {
                                                 /*@bgen(jjtree) LiteralExpression */
                                                  AstLiteralExpression jjtn000 = new AstLiteralExpression();
                                                  boolean jjtc000 = true;
                                                  .openNodeScope(jjtn000);Token t = null;
      try {
        t = jj_consume_token();
                               .closeNodeScope(jjtn000true);
                               jjtc000 = false;
                               jjtn000.setImage(t.image);
      } finally {
        if (jjtc000) {
          .closeNodeScope(jjtn000true);
       }
     }
   }
 
 /*
  * DeferredExpression
  * #{..} Expressions
  */
   final public void DeferredExpression() throws ParseException {
                                                  /*@bgen(jjtree) DeferredExpression */
   boolean jjtc000 = true;
   .openNodeScope(jjtn000);
     try {
       Expression();
     } catch (Throwable jjte000) {
       if (jjtc000) {
         .clearNodeScope(jjtn000);
         jjtc000 = false;
       } else {
         .popNode();
       }
       if (jjte000 instanceof RuntimeException) {
         {if (truethrow (RuntimeException)jjte000;}
       }
       if (jjte000 instanceof ParseException) {
         {if (truethrow (ParseException)jjte000;}
       }
       {if (truethrow (Error)jjte000;}
     } finally {
       if (jjtc000) {
         .closeNodeScope(jjtn000true);
       }
     }
   }
 
 /*
  * DynamicExpression
  * ${..} Expressions
  */
   final public void DynamicExpression() throws ParseException {
                                                /*@bgen(jjtree) DynamicExpression */
   boolean jjtc000 = true;
   .openNodeScope(jjtn000);
     try {
       Expression();
     } catch (Throwable jjte000) {
       if (jjtc000) {
         .clearNodeScope(jjtn000);
         jjtc000 = false;
       } else {
         .popNode();
       }
       if (jjte000 instanceof RuntimeException) {
         {if (truethrow (RuntimeException)jjte000;}
       }
       if (jjte000 instanceof ParseException) {
         {if (truethrow (ParseException)jjte000;}
       }
       {if (truethrow (Error)jjte000;}
     } finally {
       if (jjtc000) {
         .closeNodeScope(jjtn000true);
       }
     }
   }
 
 /*
  * Expression
  * EL Expression Language Root, goes to Choice
  */
   final public void Expression() throws ParseException {
     Choice();
   }
 
 /*
  * Choice
  * For Choice markup a ? b : c, then Or
  */
   final public void Choice() throws ParseException {
     Or();
     label_2:
     while (true) {
       if (jj_2_1(3)) {
         ;
       } else {
         break label_2;
       }
       Choice();
       jj_consume_token();
                                                          AstChoice jjtn001 = new AstChoice();
                                                          boolean jjtc001 = true;
                                                          .openNodeScope(jjtn001);
       try {
         Choice();
       } catch (Throwable jjte001) {
                                                          if (jjtc001) {
                                                            .clearNodeScope(jjtn001);
                                                            jjtc001 = false;
                                                          } else {
                                                            .popNode();
                                                          }
                                                          if (jjte001 instanceof RuntimeException) {
                                                            {if (truethrow (RuntimeException)jjte001;}
                                                          }
                                                          if (jjte001 instanceof ParseException) {
                                                            {if (truethrow (ParseException)jjte001;}
                                                          }
                                                          {if (truethrow (Error)jjte001;}
       } finally {
                                                          if (jjtc001) {
                                                            .closeNodeScope(jjtn001,  3);
                                                          }
       }
     }
   }
 
 /*
  * Or
  * For 'or' '||', then And
  */
   final public void Or() throws ParseException {
     And();
     label_3:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case :
       case :
         ;
         break;
       default:
         [2] = ;
         break label_3;
       }
       switch ((==-1)?jj_ntk():) {
       case :
         jj_consume_token();
         break;
       case :
         jj_consume_token();
         break;
       default:
         [3] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
                            AstOr jjtn001 = new AstOr();
                            boolean jjtc001 = true;
                            .openNodeScope(jjtn001);
       try {
         And();
       } catch (Throwable jjte001) {
                            if (jjtc001) {
                              .clearNodeScope(jjtn001);
                              jjtc001 = false;
                            } else {
                              .popNode();
                            }
                            if (jjte001 instanceof RuntimeException) {
                              {if (truethrow (RuntimeException)jjte001;}
                            }
                            if (jjte001 instanceof ParseException) {
                              {if (truethrow (ParseException)jjte001;}
                            }
                            {if (truethrow (Error)jjte001;}
       } finally {
                            if (jjtc001) {
                              .closeNodeScope(jjtn001,  2);
                            }
       }
     }
   }
 
 /*
  * And
  * For 'and' '&&', then Equality
  */
   final public void And() throws ParseException {
     Equality();
     label_4:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case :
       case :
         ;
         break;
       default:
         [4] = ;
         break label_4;
       }
       switch ((==-1)?jj_ntk():) {
       case :
         jj_consume_token();
         break;
       case :
         jj_consume_token();
         break;
       default:
         [5] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
                                   AstAnd jjtn001 = new AstAnd();
                                   boolean jjtc001 = true;
                                   .openNodeScope(jjtn001);
       try {
         Equality();
       } catch (Throwable jjte001) {
                                   if (jjtc001) {
                                     .clearNodeScope(jjtn001);
                                     jjtc001 = false;
                                   } else {
                                     .popNode();
                                   }
                                   if (jjte001 instanceof RuntimeException) {
                                     {if (truethrow (RuntimeException)jjte001;}
                                   }
                                   if (jjte001 instanceof ParseException) {
                                     {if (truethrow (ParseException)jjte001;}
                                   }
                                   {if (truethrow (Error)jjte001;}
       } finally {
                                   if (jjtc001) {
                                     .closeNodeScope(jjtn001,  2);
                                   }
       }
     }
   }
 
 /*
  * Equality
  * For '==' 'eq' '!=' 'ne', then Compare
  */
   final public void Equality() throws ParseException {
     Compare();
     label_5:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case :
       case :
       case :
       case :
         ;
         break;
       default:
         [6] = ;
         break label_5;
       }
       switch ((==-1)?jj_ntk():) {
       case :
       case :
         switch ((==-1)?jj_ntk():) {
         case :
           jj_consume_token();
           break;
         case :
           jj_consume_token();
           break;
         default:
           [7] = ;
           jj_consume_token(-1);
           throw new ParseException();
         }
                          AstEqual jjtn001 = new AstEqual();
                          boolean jjtc001 = true;
                          .openNodeScope(jjtn001);
         try {
           Compare();
         } catch (Throwable jjte001) {
                          if (jjtc001) {
                            .clearNodeScope(jjtn001);
                            jjtc001 = false;
                          } else {
                            .popNode();
                          }
                          if (jjte001 instanceof RuntimeException) {
                            {if (truethrow (RuntimeException)jjte001;}
                          }
                          if (jjte001 instanceof ParseException) {
                            {if (truethrow (ParseException)jjte001;}
                          }
                          {if (truethrow (Error)jjte001;}
         } finally {
                          if (jjtc001) {
                            .closeNodeScope(jjtn001,  2);
                          }
         }
         break;
       case :
       case :
         switch ((==-1)?jj_ntk():) {
         case :
           jj_consume_token();
           break;
         case :
           jj_consume_token();
           break;
         default:
           [8] = ;
           jj_consume_token(-1);
           throw new ParseException();
         }
                          AstNotEqual jjtn002 = new AstNotEqual();
                          boolean jjtc002 = true;
                          .openNodeScope(jjtn002);
         try {
           Compare();
         } catch (Throwable jjte002) {
                          if (jjtc002) {
                            .clearNodeScope(jjtn002);
                            jjtc002 = false;
                          } else {
                            .popNode();
                          }
                          if (jjte002 instanceof RuntimeException) {
                            {if (truethrow (RuntimeException)jjte002;}
                          }
                          if (jjte002 instanceof ParseException) {
                            {if (truethrow (ParseException)jjte002;}
                          }
                          {if (truethrow (Error)jjte002;}
         } finally {
                          if (jjtc002) {
                            .closeNodeScope(jjtn002,  2);
                          }
         }
         break;
       default:
         [9] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
 /*
  * Compare
  * For a bunch of them, then Math
  */
   final public void Compare() throws ParseException {
     Math();
     label_6:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case :
       case :
       case :
       case :
       case :
       case :
       case :
       case :
         ;
         break;
       default:
         [10] = ;
         break label_6;
       }
       switch ((==-1)?jj_ntk():) {
       case :
       case :
         switch ((==-1)?jj_ntk():) {
         case :
           jj_consume_token();
           break;
         case :
           jj_consume_token();
           break;
         default:
           [11] = ;
           jj_consume_token(-1);
           throw new ParseException();
         }
                          AstLessThan jjtn001 = new AstLessThan();
                          boolean jjtc001 = true;
                          .openNodeScope(jjtn001);
         try {
           Math();
         } catch (Throwable jjte001) {
                          if (jjtc001) {
                            .clearNodeScope(jjtn001);
                            jjtc001 = false;
                          } else {
                            .popNode();
                          }
                          if (jjte001 instanceof RuntimeException) {
                            {if (truethrow (RuntimeException)jjte001;}
                          }
                          if (jjte001 instanceof ParseException) {
                            {if (truethrow (ParseException)jjte001;}
                          }
                          {if (truethrow (Error)jjte001;}
         } finally {
                          if (jjtc001) {
                            .closeNodeScope(jjtn001,  2);
                          }
         }
         break;
       case :
       case :
         switch ((==-1)?jj_ntk():) {
         case :
           jj_consume_token();
           break;
         case :
           jj_consume_token();
           break;
         default:
           [12] = ;
           jj_consume_token(-1);
           throw new ParseException();
         }
                          AstGreaterThan jjtn002 = new AstGreaterThan();
                          boolean jjtc002 = true;
                          .openNodeScope(jjtn002);
         try {
           Math();
         } catch (Throwable jjte002) {
                          if (jjtc002) {
                            .clearNodeScope(jjtn002);
                            jjtc002 = false;
                          } else {
                            .popNode();
                          }
                          if (jjte002 instanceof RuntimeException) {
                            {if (truethrow (RuntimeException)jjte002;}
                          }
                          if (jjte002 instanceof ParseException) {
                            {if (truethrow (ParseException)jjte002;}
                          }
                          {if (truethrow (Error)jjte002;}
         } finally {
                          if (jjtc002) {
                            .closeNodeScope(jjtn002,  2);
                          }
         }
         break;
       case :
       case :
         switch ((==-1)?jj_ntk():) {
         case :
           jj_consume_token();
           break;
         case :
           jj_consume_token();
           break;
         default:
           [13] = ;
           jj_consume_token(-1);
           throw new ParseException();
         }
                          AstLessThanEqual jjtn003 = new AstLessThanEqual();
                          boolean jjtc003 = true;
                          .openNodeScope(jjtn003);
         try {
           Math();
         } catch (Throwable jjte003) {
                          if (jjtc003) {
                            .clearNodeScope(jjtn003);
                            jjtc003 = false;
                          } else {
                            .popNode();
                          }
                          if (jjte003 instanceof RuntimeException) {
                            {if (truethrow (RuntimeException)jjte003;}
                          }
                          if (jjte003 instanceof ParseException) {
                            {if (truethrow (ParseException)jjte003;}
                          }
                          {if (truethrow (Error)jjte003;}
         } finally {
                          if (jjtc003) {
                            .closeNodeScope(jjtn003,  2);
                          }
         }
         break;
       case :
       case :
         switch ((==-1)?jj_ntk():) {
         case :
           jj_consume_token();
           break;
         case :
           jj_consume_token();
           break;
         default:
           [14] = ;
           jj_consume_token(-1);
           throw new ParseException();
         }
                          AstGreaterThanEqual jjtn004 = new AstGreaterThanEqual();
                          boolean jjtc004 = true;
                          .openNodeScope(jjtn004);
         try {
           Math();
         } catch (Throwable jjte004) {
                          if (jjtc004) {
                            .clearNodeScope(jjtn004);
                            jjtc004 = false;
                          } else {
                            .popNode();
                          }
                          if (jjte004 instanceof RuntimeException) {
                            {if (truethrow (RuntimeException)jjte004;}
                          }
                          if (jjte004 instanceof ParseException) {
                            {if (truethrow (ParseException)jjte004;}
                          }
                          {if (truethrow (Error)jjte004;}
         } finally {
                          if (jjtc004) {
                            .closeNodeScope(jjtn004,  2);
                          }
         }
         break;
       default:
         [15] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
 /*
  * Math
  * For '+' '-', then Multiplication
  */
   final public void Math() throws ParseException {
     Multiplication();
     label_7:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case :
       case :
         ;
         break;
       default:
         [16] = ;
         break label_7;
       }
       switch ((==-1)?jj_ntk():) {
       case :
         jj_consume_token();
                   AstPlus jjtn001 = new AstPlus();
                   boolean jjtc001 = true;
                   .openNodeScope(jjtn001);
         try {
           Multiplication();
         } catch (Throwable jjte001) {
                   if (jjtc001) {
                     .clearNodeScope(jjtn001);
                     jjtc001 = false;
                   } else {
                     .popNode();
                   }
                   if (jjte001 instanceof RuntimeException) {
                     {if (truethrow (RuntimeException)jjte001;}
                   }
                   if (jjte001 instanceof ParseException) {
                     {if (truethrow (ParseException)jjte001;}
                   }
                   {if (truethrow (Error)jjte001;}
         } finally {
                   if (jjtc001) {
                     .closeNodeScope(jjtn001,  2);
                   }
         }
         break;
       case :
         jj_consume_token();
                    AstMinus jjtn002 = new AstMinus();
                    boolean jjtc002 = true;
                    .openNodeScope(jjtn002);
         try {
           Multiplication();
         } catch (Throwable jjte002) {
                    if (jjtc002) {
                      .clearNodeScope(jjtn002);
                      jjtc002 = false;
                    } else {
                      .popNode();
                    }
                    if (jjte002 instanceof RuntimeException) {
                      {if (truethrow (RuntimeException)jjte002;}
                    }
                    if (jjte002 instanceof ParseException) {
                      {if (truethrow (ParseException)jjte002;}
                    }
                    {if (truethrow (Error)jjte002;}
         } finally {
                    if (jjtc002) {
                      .closeNodeScope(jjtn002,  2);
                    }
         }
         break;
       default:
         [17] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
 /*
  * Multiplication
  * For a bunch of them, then Unary
  */
   final public void Multiplication() throws ParseException {
     Unary();
     label_8:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case :
       case :
       case :
       case :
       case :
         ;
         break;
       default:
         [18] = ;
         break label_8;
       }
       switch ((==-1)?jj_ntk():) {
       case :
         jj_consume_token();
                   AstMult jjtn001 = new AstMult();
                   boolean jjtc001 = true;
                   .openNodeScope(jjtn001);
         try {
           Unary();
         } catch (Throwable jjte001) {
                   if (jjtc001) {
                     .clearNodeScope(jjtn001);
                     jjtc001 = false;
                   } else {
                     .popNode();
                   }
                   if (jjte001 instanceof RuntimeException) {
                     {if (truethrow (RuntimeException)jjte001;}
                   }
                   if (jjte001 instanceof ParseException) {
                     {if (truethrow (ParseException)jjte001;}
                   }
                   {if (truethrow (Error)jjte001;}
         } finally {
                   if (jjtc001) {
                     .closeNodeScope(jjtn001,  2);
                   }
         }
         break;
       case :
       case :
         switch ((==-1)?jj_ntk():) {
         case :
           jj_consume_token();
           break;
         case :
           jj_consume_token();
           break;
         default:
           [19] = ;
           jj_consume_token(-1);
           throw new ParseException();
         }
                            AstDiv jjtn002 = new AstDiv();
                            boolean jjtc002 = true;
                            .openNodeScope(jjtn002);
         try {
           Unary();
         } catch (Throwable jjte002) {
                            if (jjtc002) {
                              .clearNodeScope(jjtn002);
                              jjtc002 = false;
                            } else {
                              .popNode();
                            }
                            if (jjte002 instanceof RuntimeException) {
                              {if (truethrow (RuntimeException)jjte002;}
                            }
                            if (jjte002 instanceof ParseException) {
                              {if (truethrow (ParseException)jjte002;}
                            }
                            {if (truethrow (Error)jjte002;}
         } finally {
                            if (jjtc002) {
                              .closeNodeScope(jjtn002,  2);
                            }
         }
         break;
       case :
       case :
         switch ((==-1)?jj_ntk():) {
         case :
           jj_consume_token();
           break;
         case :
           jj_consume_token();
           break;
         default:
           [20] = ;
           jj_consume_token(-1);
           throw new ParseException();
         }
                            AstMod jjtn003 = new AstMod();
                            boolean jjtc003 = true;
                            .openNodeScope(jjtn003);
         try {
           Unary();
         } catch (Throwable jjte003) {
                            if (jjtc003) {
                              .clearNodeScope(jjtn003);
                              jjtc003 = false;
                            } else {
                              .popNode();
                            }
                            if (jjte003 instanceof RuntimeException) {
                              {if (truethrow (RuntimeException)jjte003;}
                            }
                            if (jjte003 instanceof ParseException) {
                              {if (truethrow (ParseException)jjte003;}
                            }
                            {if (truethrow (Error)jjte003;}
         } finally {
                            if (jjtc003) {
                              .closeNodeScope(jjtn003,  2);
                            }
         }
         break;
       default:
         [21] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
 /*
  * Unary
  * For '-' '!' 'not' 'empty', then Value
  */
   final public void Unary() throws ParseException {
     switch ((==-1)?jj_ntk():) {
     case :
       jj_consume_token();
                   AstNegative jjtn001 = new AstNegative();
                   boolean jjtc001 = true;
                   .openNodeScope(jjtn001);
       try {
         Unary();
       } catch (Throwable jjte001) {
                   if (jjtc001) {
                     .clearNodeScope(jjtn001);
                     jjtc001 = false;
                   } else {
                     .popNode();
                   }
                   if (jjte001 instanceof RuntimeException) {
                     {if (truethrow (RuntimeException)jjte001;}
                   }
                   if (jjte001 instanceof ParseException) {
                     {if (truethrow (ParseException)jjte001;}
                   }
                   {if (truethrow (Error)jjte001;}
       } finally {
                   if (jjtc001) {
                     .closeNodeScope(jjtn001true);
                   }
       }
       break;
     case :
     case :
       switch ((==-1)?jj_ntk():) {
       case :
         jj_consume_token();
         break;
       case :
         jj_consume_token();
         break;
       default:
         [22] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
                           AstNot jjtn002 = new AstNot();
                           boolean jjtc002 = true;
                           .openNodeScope(jjtn002);
       try {
         Unary();
       } catch (Throwable jjte002) {
                           if (jjtc002) {
                             .clearNodeScope(jjtn002);
                             jjtc002 = false;
                           } else {
                             .popNode();
                           }
                           if (jjte002 instanceof RuntimeException) {
                             {if (truethrow (RuntimeException)jjte002;}
                           }
                           if (jjte002 instanceof ParseException) {
                             {if (truethrow (ParseException)jjte002;}
                           }
                           {if (truethrow (Error)jjte002;}
       } finally {
                           if (jjtc002) {
                             .closeNodeScope(jjtn002true);
                           }
       }
       break;
     case :
       jj_consume_token();
                   AstEmpty jjtn003 = new AstEmpty();
                   boolean jjtc003 = true;
                   .openNodeScope(jjtn003);
       try {
         Unary();
       } catch (Throwable jjte003) {
                   if (jjtc003) {
                     .clearNodeScope(jjtn003);
                     jjtc003 = false;
                   } else {
                     .popNode();
                   }
                   if (jjte003 instanceof RuntimeException) {
                     {if (truethrow (RuntimeException)jjte003;}
                   }
                   if (jjte003 instanceof ParseException) {
                     {if (truethrow (ParseException)jjte003;}
                   }
                   {if (truethrow (Error)jjte003;}
       } finally {
                   if (jjtc003) {
                     .closeNodeScope(jjtn003true);
                   }
       }
       break;
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
       Value();
       break;
     default:
       [23] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
   }
 
 /*
  * Value
  * Defines Prefix plus zero or more Suffixes
  */
   final public void Value() throws ParseException {
       AstValue jjtn001 = new AstValue();
       boolean jjtc001 = true;
       .openNodeScope(jjtn001);
     try {
       ValuePrefix();
       label_9:
       while (true) {
         switch ((==-1)?jj_ntk():) {
         case :
         case :
           ;
           break;
         default:
           [24] = ;
           break label_9;
         }
         ValueSuffix();
       }
     } catch (Throwable jjte001) {
       if (jjtc001) {
         .clearNodeScope(jjtn001);
         jjtc001 = false;
       } else {
         .popNode();
       }
       if (jjte001 instanceof RuntimeException) {
         {if (truethrow (RuntimeException)jjte001;}
       }
       if (jjte001 instanceof ParseException) {
         {if (truethrow (ParseException)jjte001;}
       }
       {if (truethrow (Error)jjte001;}
     } finally {
       if (jjtc001) {
         .closeNodeScope(jjtn001.nodeArity() > 1);
       }
    }
  }
 * ValuePrefix
 * For Literals, Variables, and Functions
 */
  final public void ValuePrefix() throws ParseException {
    switch ((==-1)?jj_ntk():) {
    case :
    case :
    case :
    case :
    case :
      Literal();
      break;
    case :
    case :
      NonLiteral();
      break;
    default:
      [25] = ;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }
 * ValueSuffix
 * Either dot or bracket notation
 */
  final public void ValueSuffix() throws ParseException {
    switch ((==-1)?jj_ntk():) {
    case :
      DotSuffix();
      break;
    case :
      BracketSuffix();
      break;
    default:
      [26] = ;
      jj_consume_token(-1);
      throw new ParseException();
    }
    switch ((==-1)?jj_ntk():) {
    case :
      MethodParameters();
      break;
    default:
      [27] = ;
      ;
    }
  }
 * DotSuffix
 * Dot Property
 */
  final public void DotSuffix() throws ParseException {
                               /*@bgen(jjtree) DotSuffix */
                                AstDotSuffix jjtn000 = new AstDotSuffix();