View Javadoc

    1   /* Generated By:JJTree&JavaCC: Do not edit this line. ExpressionParser.java */
    2   /***************************************************************************************
    3    * Copyright (c) Jonas BonŽr, Alexandre Vasseur. All rights reserved.                 *
    4    * http://aspectwerkz.codehaus.org                                                    *
    5    * ---------------------------------------------------------------------------------- *
    6    * The software in this package is published under the terms of the LGPL license      *
    7    * a copy of which has been included with this distribution in the license.txt file.  *
    8    **************************************************************************************/
    9   package org.codehaus.aspectwerkz.expression.ast;
    10
    11  import java.lang.reflect.Modifier;
    12  import java.io.Reader;
    13  import java.io.StringReader;
    14
    15  /***
    16   * Usage:
    17   *  <pre>
    18   *     ExpressionParser parser = new ExpressionParser(System.in); // can be only one
    19   *     ASTRoot root = parser.parse("call(@RequiresNew public * foo.Bar.*(String, ..) AND withincode(* foo.Baz.within(..)");
    20   *     Expression expression = new Expression(root);
    21   *     ...
    22   *  </pre>
    23   *
    24   *
    25   * TODO: the grammar is still fragile
    26   *
    27   * @author <a href="mailto:jboner@codehaus.org">Jonas BonŽr</a>
    28   * @author <a href="mailto:alex@gnilux.com">Alexandre Vasseur</a>
    29   * @author <a href="mailto:the_mindstorm@evolva.ro">Alex Popescu</a>
    30   */
    31  public class ExpressionParser/*@bgen(jjtree)*/implements ExpressionParserTreeConstants, ExpressionParserConstants {/*@bgen(jjtree)*/
    32    protected static JJTExpressionParserState jjtree = new JJTExpressionParserState();
    33      public ASTRoot parse(String expression) throws ParseException {
    34          return parse(new StringReader(expression));
    35      }
    36
    37      public ASTRoot parse(Reader reader) throws ParseException {
    38          ReInit(reader);
    39          return Root();
    40      }
    41
    42  //------------------ Bootstrap ------------------
    43
    44  /***
    45   * Entry point.
    46   */
    47    static final public ASTRoot Root() throws ParseException {
    48                          /*@bgen(jjtree) Root */
    49    ASTRoot jjtn000 = new ASTRoot(JJTROOT);
    50    boolean jjtc000 = true;
    51    jjtree.openNodeScope(jjtn000);
    52      try {
    53        Expression();
    54        jj_consume_token(0);
    55        jjtree.closeNodeScope(jjtn000, true);
    56        jjtc000 = false;
    57        {if (true) return jjtn000;}
    58      } catch (Throwable jjte000) {
    59        if (jjtc000) {
    60          jjtree.clearNodeScope(jjtn000);
    61          jjtc000 = false;
    62        } else {
    63          jjtree.popNode();
    64        }
    65        if (jjte000 instanceof RuntimeException) {
    66          {if (true) throw (RuntimeException)jjte000;}
    67        }
    68        if (jjte000 instanceof ParseException) {
    69          {if (true) throw (ParseException)jjte000;}
    70        }
    71        {if (true) throw (Error)jjte000;}
    72      } finally {
    73        if (jjtc000) {
    74          jjtree.closeNodeScope(jjtn000, true);
    75        }
    76      }
    77      throw new Error("Missing return statement in function");
    78    }
    79
    80  /***
    81   * Expression.
    82   */
    83    static final public void Expression() throws ParseException {
    84                                   /*@bgen(jjtree) Expression */
    85    ASTExpression jjtn000 = new ASTExpression(JJTEXPRESSION);
    86    boolean jjtc000 = true;
    87    jjtree.openNodeScope(jjtn000);
    88      try {
    89        AndExpression();
    90      } catch (Throwable jjte000) {
    91        if (jjtc000) {
    92          jjtree.clearNodeScope(jjtn000);
    93          jjtc000 = false;
    94        } else {
    95          jjtree.popNode();
    96        }
    97        if (jjte000 instanceof RuntimeException) {
    98          {if (true) throw (RuntimeException)jjte000;}
    99        }
    100       if (jjte000 instanceof ParseException) {
    101         {if (true) throw (ParseException)jjte000;}
    102       }
    103       {if (true) throw (Error)jjte000;}
    104     } finally {
    105       if (jjtc000) {
    106         jjtree.closeNodeScope(jjtn000, true);
    107       }
    108     }
    109   }
    110
    111 //------------------ Logical operators ------------------
    112
    113 /***
    114  * AndExpression.
    115  */
    116   static final public void AndExpression() throws ParseException {
    117       ASTAnd jjtn001 = new ASTAnd(JJTAND);
    118       boolean jjtc001 = true;
    119       jjtree.openNodeScope(jjtn001);
    120     try {
    121       OrExpression();
    122       label_1:
    123       while (true) {
    124         if (jj_2_1(2)) {
    125           ;
    126         } else {
    127           break label_1;
    128         }
    129         jj_consume_token(AND);
    130         OrExpression();
    131       }
    132     } catch (Throwable jjte001) {
    133       if (jjtc001) {
    134         jjtree.clearNodeScope(jjtn001);
    135         jjtc001 = false;
    136       } else {
    137         jjtree.popNode();
    138       }
    139       if (jjte001 instanceof RuntimeException) {
    140         {if (true) throw (RuntimeException)jjte001;}
    141       }
    142       if (jjte001 instanceof ParseException) {
    143         {if (true) throw (ParseException)jjte001;}
    144       }
    145       {if (true) throw (Error)jjte001;}
    146     } finally {
    147       if (jjtc001) {
    148         jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
    149       }
    150     }
    151   }
    152
    153 /***
    154  * OrExpression.
    155  */
    156   static final public void OrExpression() throws ParseException {
    157       ASTOr jjtn001 = new ASTOr(JJTOR);
    158       boolean jjtc001 = true;
    159       jjtree.openNodeScope(jjtn001);
    160     try {
    161       UnaryExpression();
    162       label_2:
    163       while (true) {
    164         if (jj_2_2(2)) {
    165           ;
    166         } else {
    167           break label_2;
    168         }
    169         jj_consume_token(OR);
    170         AndExpression();
    171       }
    172     } catch (Throwable jjte001) {
    173       if (jjtc001) {
    174         jjtree.clearNodeScope(jjtn001);
    175         jjtc001 = false;
    176       } else {
    177         jjtree.popNode();
    178       }
    179       if (jjte001 instanceof RuntimeException) {
    180         {if (true) throw (RuntimeException)jjte001;}
    181       }
    182       if (jjte001 instanceof ParseException) {
    183         {if (true) throw (ParseException)jjte001;}
    184       }
    185       {if (true) throw (Error)jjte001;}
    186     } finally {
    187       if (jjtc001) {
    188         jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
    189       }
    190     }
    191   }
    192
    193 /***
    194  * UnaryExpression.
    195  */
    196   static final public void UnaryExpression() throws ParseException {
    197     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    198     case NOT:
    199       NotExpression();
    200       break;
    201     case 86:
    202       jj_consume_token(86);
    203       Expression();
    204       jj_consume_token(87);
    205       break;
    206     case EXECUTION:
    207     case CALL:
    208     case SET:
    209     case GET:
    210     case HANDLER:
    211     case WITHIN:
    212     case WITHIN_CODE:
    213     case STATIC_INITIALIZATION:
    214     case CFLOW:
    215     case CFLOW_BELOW:
    216     case ARGS:
    217     case TARGET:
    218     case THIS:
    219     case HAS_METHOD:
    220     case HAS_FIELD:
    221     case POINTCUT_REFERENCE_WITH_ARGS:
    222     case POINTCUT_REFERENCE:
    223       Pointcut();
    224       break;
    225     default:
    226       jj_la1[0] = jj_gen;
    227       jj_consume_token(-1);
    228       throw new ParseException();
    229     }
    230   }
    231
    232 /***
    233  * NotExpression.
    234  */
    235   static final public void NotExpression() throws ParseException {
    236     jj_consume_token(NOT);
    237             ASTNot jjtn001 = new ASTNot(JJTNOT);
    238             boolean jjtc001 = true;
    239             jjtree.openNodeScope(jjtn001);
    240     try {
    241       UnaryExpression();
    242     } catch (Throwable jjte001) {
    243             if (jjtc001) {
    244               jjtree.clearNodeScope(jjtn001);
    245               jjtc001 = false;
    246             } else {
    247               jjtree.popNode();
    248             }
    249             if (jjte001 instanceof RuntimeException) {
    250               {if (true) throw (RuntimeException)jjte001;}
    251             }
    252             if (jjte001 instanceof ParseException) {
    253               {if (true) throw (ParseException)jjte001;}
    254             }
    255             {if (true) throw (Error)jjte001;}
    256     } finally {
    257             if (jjtc001) {
    258               jjtree.closeNodeScope(jjtn001, true);
    259             }
    260     }
    261   }
    262
    263 //------------------ Pointcuts ------------------
    264
    265 /***
    266  * Pointcut.
    267  */
    268   static final public void Pointcut() throws ParseException {
    269     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    270     case CALL:
    271       Call();
    272       break;
    273     case EXECUTION:
    274       Execution();
    275       break;
    276     case WITHIN_CODE:
    277       WithinCode();
    278       break;
    279     case HAS_METHOD:
    280       HasMethod();
    281       break;
    282     case SET:
    283       Set();
    284       break;
    285     case GET:
    286       Get();
    287       break;
    288     case HAS_FIELD:
    289       HasField();
    290       break;
    291     case WITHIN:
    292       Within();
    293       break;
    294     case HANDLER:
    295       Handler();
    296       break;
    297     case ARGS:
    298       Args();
    299       break;
    300     case TARGET:
    301       Target();
    302       break;
    303     case THIS:
    304       This();
    305       break;
    306     case CFLOW:
    307       Cflow();
    308       break;
    309     case CFLOW_BELOW:
    310       CflowBelow();
    311       break;
    312     case STATIC_INITIALIZATION:
    313       StaticInitialization();
    314       break;
    315     case POINTCUT_REFERENCE_WITH_ARGS:
    316     case POINTCUT_REFERENCE:
    317       PointcutReference();
    318       break;
    319     default:
    320       jj_la1[1] = jj_gen;
    321       jj_consume_token(-1);
    322       throw new ParseException();
    323     }
    324   }
    325
    326 /***
    327  * Pointcut reference.
    328  */
    329   static final public void PointcutReference() throws ParseException {
    330  /*@bgen(jjtree) PointcutReference */
    331     ASTPointcutReference jjtn000 = new ASTPointcutReference(JJTPOINTCUTREFERENCE);
    332     boolean jjtc000 = true;
    333     jjtree.openNodeScope(jjtn000);Token name;
    334     try {
    335       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    336       case POINTCUT_REFERENCE_WITH_ARGS:
    337         name = jj_consume_token(POINTCUT_REFERENCE_WITH_ARGS);
    338         break;
    339       case POINTCUT_REFERENCE:
    340         name = jj_consume_token(POINTCUT_REFERENCE);
    341         break;
    342       default:
    343         jj_la1[2] = jj_gen;
    344         jj_consume_token(-1);
    345         throw new ParseException();
    346       }
    347         jjtn000.setName(name.image);
    348       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    349       case COMMA:
    350       case EAGER_WILDCARD:
    351       case ARG_PATTERN:
    352       case ARG_ARRAY_PATTERN:
    353       case ARGS_END:
    354         ArgsParameters();
    355         jj_consume_token(ARGS_END);
    356         break;
    357       default:
    358         jj_la1[3] = jj_gen;
    359         ;
    360       }
    361     } catch (Throwable jjte000) {
    362       if (jjtc000) {
    363         jjtree.clearNodeScope(jjtn000);
    364         jjtc000 = false;
    365       } else {
    366         jjtree.popNode();
    367       }
    368       if (jjte000 instanceof RuntimeException) {
    369         {if (true) throw (RuntimeException)jjte000;}
    370       }
    371       if (jjte000 instanceof ParseException) {
    372         {if (true) throw (ParseException)jjte000;}
    373       }
    374       {if (true) throw (Error)jjte000;}
    375     } finally {
    376       if (jjtc000) {
    377         jjtree.closeNodeScope(jjtn000, true);
    378       }
    379     }
    380   }
    381
    382 /***
    383  * Execution.
    384  */
    385   static final public void Execution() throws ParseException {
    386                                /*@bgen(jjtree) Execution */
    387   ASTExecution jjtn000 = new ASTExecution(JJTEXECUTION);
    388   boolean jjtc000 = true;
    389   jjtree.openNodeScope(jjtn000);
    390     try {
    391       jj_consume_token(EXECUTION);
    392       label_3:
    393       while (true) {
    394         if (jj_2_3(2)) {
    395           ;
    396         } else {
    397           break label_3;
    398         }
    399         MethodAttribute();
    400       }
    401       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    402       case METHOD_PARAMETER_END:
    403         jj_consume_token(METHOD_PARAMETER_END);
    404         break;
    405       case METHOD_PUBLIC:
    406       case METHOD_PROTECTED:
    407       case METHOD_PRIVATE:
    408       case METHOD_STATIC:
    409       case METHOD_ABSTRACT:
    410       case METHOD_FINAL:
    411       case METHOD_NATIVE:
    412       case METHOD_SYNCHRONIZED:
    413       case METHOD_NOT:
    414       case METHOD_CLASS_PATTERN:
    415       case METHOD_ARRAY_CLASS_PATTERN:
    416       case 87:
    417         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    418         case METHOD_PUBLIC:
    419         case METHOD_PROTECTED:
    420         case METHOD_PRIVATE:
    421         case METHOD_STATIC:
    422         case METHOD_ABSTRACT:
    423         case METHOD_FINAL:
    424         case METHOD_NATIVE:
    425         case METHOD_SYNCHRONIZED:
    426         case METHOD_NOT:
    427         case METHOD_CLASS_PATTERN:
    428         case METHOD_ARRAY_CLASS_PATTERN:
    429           if (jj_2_4(4)) {
    430             ConstructorPattern();
    431           } else {
    432             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    433             case METHOD_PUBLIC:
    434             case METHOD_PROTECTED:
    435             case METHOD_PRIVATE:
    436             case METHOD_STATIC:
    437             case METHOD_ABSTRACT:
    438             case METHOD_FINAL:
    439             case METHOD_NATIVE:
    440             case METHOD_SYNCHRONIZED:
    441             case METHOD_NOT:
    442             case METHOD_CLASS_PATTERN:
    443             case METHOD_ARRAY_CLASS_PATTERN:
    444               MethodPattern();
    445               break;
    446             default:
    447               jj_la1[4] = jj_gen;
    448               jj_consume_token(-1);
    449               throw new ParseException();
    450             }
    451           }
    452           break;
    453         default:
    454           jj_la1[5] = jj_gen;
    455           ;
    456         }
    457         jj_consume_token(87);
    458         break;
    459       default:
    460         jj_la1[6] = jj_gen;
    461         jj_consume_token(-1);
    462         throw new ParseException();
    463       }
    464     } catch (Throwable jjte000) {
    465       if (jjtc000) {
    466         jjtree.clearNodeScope(jjtn000);
    467         jjtc000 = false;
    468       } else {
    469         jjtree.popNode();
    470       }
    471       if (jjte000 instanceof RuntimeException) {
    472         {if (true) throw (RuntimeException)jjte000;}
    473       }
    474       if (jjte000 instanceof ParseException) {
    475         {if (true) throw (ParseException)jjte000;}
    476       }
    477       {if (true) throw (Error)jjte000;}
    478     } finally {
    479       if (jjtc000) {
    480         jjtree.closeNodeScope(jjtn000, true);
    481       }
    482     }
    483   }
    484
    485 /***
    486  * Call.
    487  */
    488   static final public void Call() throws ParseException {
    489                      /*@bgen(jjtree) Call */
    490   ASTCall jjtn000 = new ASTCall(JJTCALL);
    491   boolean jjtc000 = true;
    492   jjtree.openNodeScope(jjtn000);
    493     try {
    494       jj_consume_token(CALL);
    495       label_4:
    496       while (true) {
    497         if (jj_2_5(2)) {
    498           ;
    499         } else {
    500           break label_4;
    501         }
    502         MethodAttribute();
    503       }
    504       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    505       case METHOD_PARAMETER_END:
    506         jj_consume_token(METHOD_PARAMETER_END);
    507         break;
    508       case METHOD_PUBLIC:
    509       case METHOD_PROTECTED:
    510       case METHOD_PRIVATE:
    511       case METHOD_STATIC:
    512       case METHOD_ABSTRACT:
    513       case METHOD_FINAL:
    514       case METHOD_NATIVE:
    515       case METHOD_SYNCHRONIZED:
    516       case METHOD_NOT:
    517       case METHOD_CLASS_PATTERN:
    518       case METHOD_ARRAY_CLASS_PATTERN:
    519       case 87:
    520         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    521         case METHOD_PUBLIC:
    522         case METHOD_PROTECTED:
    523         case METHOD_PRIVATE:
    524         case METHOD_STATIC:
    525         case METHOD_ABSTRACT:
    526         case METHOD_FINAL:
    527         case METHOD_NATIVE:
    528         case METHOD_SYNCHRONIZED:
    529         case METHOD_NOT:
    530         case METHOD_CLASS_PATTERN:
    531         case METHOD_ARRAY_CLASS_PATTERN:
    532           if (jj_2_6(4)) {
    533             ConstructorPattern();
    534           } else {
    535             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    536             case METHOD_PUBLIC:
    537             case METHOD_PROTECTED:
    538             case METHOD_PRIVATE:
    539             case METHOD_STATIC:
    540             case METHOD_ABSTRACT:
    541             case METHOD_FINAL:
    542             case METHOD_NATIVE:
    543             case METHOD_SYNCHRONIZED:
    544             case METHOD_NOT:
    545             case METHOD_CLASS_PATTERN:
    546             case METHOD_ARRAY_CLASS_PATTERN:
    547               MethodPattern();
    548               break;
    549             default:
    550               jj_la1[7] = jj_gen;
    551               jj_consume_token(-1);
    552               throw new ParseException();
    553             }
    554           }
    555           break;
    556         default:
    557           jj_la1[8] = jj_gen;
    558           ;
    559         }
    560         jj_consume_token(87);
    561         break;
    562       default:
    563         jj_la1[9] = jj_gen;
    564         jj_consume_token(-1);
    565         throw new ParseException();
    566       }
    567     } catch (Throwable jjte000) {
    568       if (jjtc000) {
    569         jjtree.clearNodeScope(jjtn000);
    570         jjtc000 = false;
    571       } else {
    572         jjtree.popNode();
    573       }
    574       if (jjte000 instanceof RuntimeException) {
    575         {if (true) throw (RuntimeException)jjte000;}
    576       }
    577       if (jjte000 instanceof ParseException) {
    578         {if (true) throw (ParseException)jjte000;}
    579       }
    580       {if (true) throw (Error)jjte000;}
    581     } finally {
    582       if (jjtc000) {
    583         jjtree.closeNodeScope(jjtn000, true);
    584       }
    585     }
    586   }
    587
    588 /***
    589  * Set.
    590  */
    591   static final public void Set() throws ParseException {
    592                    /*@bgen(jjtree) Set */
    593   ASTSet jjtn000 = new ASTSet(JJTSET);
    594   boolean jjtc000 = true;
    595   jjtree.openNodeScope(jjtn000);
    596     try {
    597       jj_consume_token(SET);
    598       label_5:
    599       while (true) {
    600         if (jj_2_7(2)) {
    601           ;
    602         } else {
    603           break label_5;
    604         }
    605         FieldAttribute();
    606       }
    607       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    608       case FIELD_PRIVATE:
    609       case FIELD_PROTECTED:
    610       case FIELD_PUBLIC:
    611       case FIELD_STATIC:
    612       case FIELD_ABSTRACT:
    613       case FIELD_FINAL:
    614       case FIELD_TRANSIENT:
    615       case FIELD_NOT:
    616       case FIELD_CLASS_PATTERN:
    617       case FIELD_ARRAY_CLASS_PATTERN:
    618         FieldPattern();
    619         break;
    620       default:
    621         jj_la1[10] = jj_gen;
    622         ;
    623       }
    624       jj_consume_token(FIELD_POINTCUT_END);
    625     } catch (Throwable jjte000) {
    626       if (jjtc000) {
    627         jjtree.clearNodeScope(jjtn000);
    628         jjtc000 = false;
    629       } else {
    630         jjtree.popNode();
    631       }
    632       if (jjte000 instanceof RuntimeException) {
    633         {if (true) throw (RuntimeException)jjte000;}
    634       }
    635       if (jjte000 instanceof ParseException) {
    636         {if (true) throw (ParseException)jjte000;}
    637       }
    638       {if (true) throw (Error)jjte000;}
    639     } finally {
    640       if (jjtc000) {
    641         jjtree.closeNodeScope(jjtn000, true);
    642       }
    643     }
    644   }
    645
    646 /***
    647  * Get.
    648  */
    649   static final public void Get() throws ParseException {
    650                    /*@bgen(jjtree) Get */
    651   ASTGet jjtn000 = new ASTGet(JJTGET);
    652   boolean jjtc000 = true;
    653   jjtree.openNodeScope(jjtn000);
    654     try {
    655       jj_consume_token(GET);
    656       label_6:
    657       while (true) {
    658         if (jj_2_8(2)) {
    659           ;
    660         } else {
    661           break label_6;
    662         }
    663         FieldAttribute();
    664       }
    665       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    666       case FIELD_PRIVATE:
    667       case FIELD_PROTECTED:
    668       case FIELD_PUBLIC:
    669       case FIELD_STATIC:
    670       case FIELD_ABSTRACT:
    671       case FIELD_FINAL:
    672       case FIELD_TRANSIENT:
    673       case FIELD_NOT:
    674       case FIELD_CLASS_PATTERN:
    675       case FIELD_ARRAY_CLASS_PATTERN:
    676         FieldPattern();
    677         break;
    678       default:
    679         jj_la1[11] = jj_gen;
    680         ;
    681       }
    682       jj_consume_token(FIELD_POINTCUT_END);
    683     } catch (Throwable jjte000) {
    684       if (jjtc000) {
    685         jjtree.clearNodeScope(jjtn000);
    686         jjtc000 = false;
    687       } else {
    688         jjtree.popNode();
    689       }
    690       if (jjte000 instanceof RuntimeException) {
    691         {if (true) throw (RuntimeException)jjte000;}
    692       }
    693       if (jjte000 instanceof ParseException) {
    694         {if (true) throw (ParseException)jjte000;}
    695       }
    696       {if (true) throw (Error)jjte000;}
    697     } finally {
    698       if (jjtc000) {
    699         jjtree.closeNodeScope(jjtn000, true);
    700       }
    701     }
    702   }
    703
    704 /***
    705  * Handler.
    706  */
    707   static final public void Handler() throws ParseException {
    708                            /*@bgen(jjtree) Handler */
    709   ASTHandler jjtn000 = new ASTHandler(JJTHANDLER);
    710   boolean jjtc000 = true;
    711   jjtree.openNodeScope(jjtn000);
    712     try {
    713       jj_consume_token(HANDLER);
    714       ClassPattern();
    715       jj_consume_token(CLASS_POINTCUT_END);
    716     } catch (Throwable jjte000) {
    717       if (jjtc000) {
    718         jjtree.clearNodeScope(jjtn000);
    719         jjtc000 = false;
    720       } else {
    721         jjtree.popNode();
    722       }
    723       if (jjte000 instanceof RuntimeException) {
    724         {if (true) throw (RuntimeException)jjte000;}
    725       }
    726       if (jjte000 instanceof ParseException) {
    727         {if (true) throw (ParseException)jjte000;}
    728       }
    729       {if (true) throw (Error)jjte000;}
    730     } finally {
    731       if (jjtc000) {
    732         jjtree.closeNodeScope(jjtn000, true);
    733       }
    734     }
    735   }
    736
    737 /***
    738  * Within.
    739  */
    740   static final public void Within() throws ParseException {
    741                          /*@bgen(jjtree) Within */
    742   ASTWithin jjtn000 = new ASTWithin(JJTWITHIN);
    743   boolean jjtc000 = true;
    744   jjtree.openNodeScope(jjtn000);
    745     try {
    746       jj_consume_token(WITHIN);
    747       label_7:
    748       while (true) {
    749         if (jj_2_9(2)) {
    750           ;
    751         } else {
    752           break label_7;
    753         }
    754         ClassAttribute();
    755       }
    756       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    757       case EAGER_WILDCARD:
    758       case CLASS_PRIVATE:
    759       case CLASS_PROTECTED:
    760       case CLASS_PUBLIC:
    761       case CLASS_STATIC:
    762       case CLASS_ABSTRACT:
    763       case CLASS_FINAL:
    764       case CLASS_NOT:
    765       case CLASS_PATTERN:
    766         ClassPattern();
    767         break;
    768       default:
    769         jj_la1[12] = jj_gen;
    770         ;
    771       }
    772       jj_consume_token(CLASS_POINTCUT_END);
    773     } catch (Throwable jjte000) {
    774       if (jjtc000) {
    775         jjtree.clearNodeScope(jjtn000);
    776         jjtc000 = false;
    777       } else {
    778         jjtree.popNode();
    779       }
    780       if (jjte000 instanceof RuntimeException) {
    781         {if (true) throw (RuntimeException)jjte000;}
    782       }
    783       if (jjte000 instanceof ParseException) {
    784         {if (true) throw (ParseException)jjte000;}
    785       }
    786       {if (true) throw (Error)jjte000;}
    787     } finally {
    788       if (jjtc000) {
    789         jjtree.closeNodeScope(jjtn000, true);
    790       }
    791     }
    792   }
    793
    794 /***
    795  * WithinCode.
    796  */
    797   static final public void WithinCode() throws ParseException {
    798                                  /*@bgen(jjtree) WithinCode */
    799         ASTWithinCode jjtn000 = new ASTWithinCode(JJTWITHINCODE);
    800         boolean jjtc000 = true;
    801         jjtree.openNodeScope(jjtn000);Token tkn = null;
    802     try {
    803       jj_consume_token(WITHIN_CODE);
    804       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    805       case TYPE_STATICINITIALIZATION:
    806         WithinStaticInitialization();
    807         jj_consume_token(87);
    808                   jjtree.closeNodeScope(jjtn000, true);
    809                   jjtc000 = false;
    810                         jjtn000.setStaticInitializer(true);
    811         break;
    812       case METHOD_PUBLIC:
    813       case METHOD_PROTECTED:
    814       case METHOD_PRIVATE:
    815       case METHOD_STATIC:
    816       case METHOD_ABSTRACT:
    817       case METHOD_FINAL:
    818       case METHOD_NATIVE:
    819       case METHOD_SYNCHRONIZED:
    820       case METHOD_NOT:
    821       case METHOD_ANNOTATION:
    822       case METHOD_CLASS_PATTERN:
    823       case METHOD_ARRAY_CLASS_PATTERN:
    824       case METHOD_PARAMETER_END:
    825       case 87:
    826         label_8:
    827         while (true) {
    828           if (jj_2_10(2)) {
    829             ;
    830           } else {
    831             break label_8;
    832           }
    833           MethodAttribute();
    834         }
    835         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    836         case METHOD_PARAMETER_END:
    837           jj_consume_token(METHOD_PARAMETER_END);
    838           break;
    839         case METHOD_PUBLIC:
    840         case METHOD_PROTECTED:
    841         case METHOD_PRIVATE:
    842         case METHOD_STATIC:
    843         case METHOD_ABSTRACT:
    844         case METHOD_FINAL:
    845         case METHOD_NATIVE:
    846         case METHOD_SYNCHRONIZED:
    847         case METHOD_NOT:
    848         case METHOD_CLASS_PATTERN:
    849         case METHOD_ARRAY_CLASS_PATTERN:
    850         case 87:
    851           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    852           case METHOD_PUBLIC:
    853           case METHOD_PROTECTED:
    854           case METHOD_PRIVATE:
    855           case METHOD_STATIC:
    856           case METHOD_ABSTRACT:
    857           case METHOD_FINAL:
    858           case METHOD_NATIVE:
    859           case METHOD_SYNCHRONIZED:
    860           case METHOD_NOT:
    861           case METHOD_CLASS_PATTERN:
    862           case METHOD_ARRAY_CLASS_PATTERN:
    863             if (jj_2_11(4)) {
    864               ConstructorPattern();
    865             } else {
    866               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    867               case METHOD_PUBLIC:
    868               case METHOD_PROTECTED:
    869               case METHOD_PRIVATE:
    870               case METHOD_STATIC:
    871               case METHOD_ABSTRACT:
    872               case METHOD_FINAL:
    873               case METHOD_NATIVE:
    874               case METHOD_SYNCHRONIZED:
    875               case METHOD_NOT:
    876               case METHOD_CLASS_PATTERN:
    877               case METHOD_ARRAY_CLASS_PATTERN:
    878                 MethodPattern();
    879                 break;
    880               default:
    881                 jj_la1[13] = jj_gen;
    882                 jj_consume_token(-1);
    883                 throw new ParseException();
    884               }
    885             }
    886             break;
    887           default:
    888             jj_la1[14] = jj_gen;
    889             ;
    890           }
    891           jj_consume_token(87);
    892           break;
    893         default:
    894           jj_la1[15] = jj_gen;
    895           jj_consume_token(-1);
    896           throw new ParseException();
    897         }
    898         break;
    899       default:
    900         jj_la1[16] = jj_gen;
    901         jj_consume_token(-1);
    902         throw new ParseException();
    903       }
    904     } catch (Throwable jjte000) {
    905           if (jjtc000) {
    906             jjtree.clearNodeScope(jjtn000);
    907             jjtc000 = false;
    908           } else {
    909             jjtree.popNode();
    910           }
    911           if (jjte000 instanceof RuntimeException) {
    912             {if (true) throw (RuntimeException)jjte000;}
    913           }
    914           if (jjte000 instanceof ParseException) {
    915             {if (true) throw (ParseException)jjte000;}
    916           }
    917           {if (true) throw (Error)jjte000;}
    918     } finally {
    919           if (jjtc000) {
    920             jjtree.closeNodeScope(jjtn000, true);
    921           }
    922     }
    923   }
    924
    925   static final public void WithinStaticInitialization() throws ParseException {
    926                                                            /*@bgen(jjtree) StaticInitialization */
    927   ASTStaticInitialization jjtn000 = new ASTStaticInitialization(JJTSTATICINITIALIZATION);
    928   boolean jjtc000 = true;
    929   jjtree.openNodeScope(jjtn000);
    930     try {
    931       jj_consume_token(TYPE_STATICINITIALIZATION);
    932       jj_consume_token(METHOD_PARAMETER_START);
    933       label_9:
    934       while (true) {
    935         if (jj_2_12(2)) {
    936           ;
    937         } else {
    938           break label_9;
    939         }
    940         MethodAttribute();
    941       }
    942       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    943       case METHOD_PUBLIC:
    944       case METHOD_PROTECTED:
    945       case METHOD_PRIVATE:
    946       case METHOD_STATIC:
    947       case METHOD_ABSTRACT:
    948       case METHOD_FINAL:
    949       case METHOD_NOT:
    950       case METHOD_CLASS_PATTERN:
    951         StaticInitializationPattern();
    952         break;
    953       default:
    954         jj_la1[17] = jj_gen;
    955         ;
    956       }
    957       jj_consume_token(METHOD_PARAMETER_END);
    958     } catch (Throwable jjte000) {
    959                   if (jjtc000) {
    960                     jjtree.clearNodeScope(jjtn000);
    961                     jjtc000 = false;
    962                   } else {
    963                     jjtree.popNode();
    964                   }
    965                   if (jjte000 instanceof RuntimeException) {
    966                     {if (true) throw (RuntimeException)jjte000;}
    967                   }
    968                   if (jjte000 instanceof ParseException) {
    969                     {if (true) throw (ParseException)jjte000;}
    970                   }
    971                   {if (true) throw (Error)jjte000;}
    972     } finally {
    973                   if (jjtc000) {
    974                     jjtree.closeNodeScope(jjtn000, true);
    975                   }
    976     }
    977   }
    978
    979   static final public void StaticInitializationPattern() throws ParseException {
    980  /*@bgen(jjtree) ClassPattern */
    981         ASTClassPattern jjtn000 = new ASTClassPattern(JJTCLASSPATTERN);
    982         boolean jjtc000 = true;
    983         jjtree.openNodeScope(jjtn000);Token tkn = null;
    984     try {
    985       label_10:
    986       while (true) {
    987         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    988         case METHOD_PUBLIC:
    989         case METHOD_PROTECTED:
    990         case METHOD_PRIVATE:
    991         case METHOD_STATIC:
    992         case METHOD_ABSTRACT:
    993         case METHOD_FINAL:
    994         case METHOD_NOT:
    995           ;
    996           break;
    997         default:
    998           jj_la1[18] = jj_gen;
    999           break label_10;
    1000         }
    1001         StaticInitializationPatternModifier();
    1002       }
    1003       tkn = jj_consume_token(METHOD_CLASS_PATTERN);
    1004           jjtree.closeNodeScope(jjtn000, true);
    1005           jjtc000 = false;
    1006                 jjtn000.setTypePattern(tkn.image);
    1007     } catch (Throwable jjte000) {
    1008           if (jjtc000) {
    1009             jjtree.clearNodeScope(jjtn000);
    1010             jjtc000 = false;
    1011           } else {
    1012             jjtree.popNode();
    1013           }
    1014           if (jjte000 instanceof RuntimeException) {
    1015             {if (true) throw (RuntimeException)jjte000;}
    1016           }
    1017           if (jjte000 instanceof ParseException) {
    1018             {if (true) throw (ParseException)jjte000;}
    1019           }
    1020           {if (true) throw (Error)jjte000;}
    1021     } finally {
    1022           if (jjtc000) {
    1023             jjtree.closeNodeScope(jjtn000, true);
    1024           }
    1025     }
    1026   }
    1027
    1028 /***
    1029  * StaticInitialization.
    1030  */
    1031   static final public void StaticInitialization() throws ParseException {
    1032                                                      /*@bgen(jjtree) StaticInitialization */
    1033   ASTStaticInitialization jjtn000 = new ASTStaticInitialization(JJTSTATICINITIALIZATION);
    1034   boolean jjtc000 = true;
    1035   jjtree.openNodeScope(jjtn000);
    1036     try {
    1037       jj_consume_token(STATIC_INITIALIZATION);
    1038       label_11:
    1039       while (true) {
    1040         if (jj_2_13(2)) {
    1041           ;
    1042         } else {
    1043           break label_11;
    1044         }
    1045         ClassAttribute();
    1046       }
    1047       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1048       case EAGER_WILDCARD:
    1049       case CLASS_PRIVATE:
    1050       case CLASS_PROTECTED:
    1051       case CLASS_PUBLIC:
    1052       case CLASS_STATIC:
    1053       case CLASS_ABSTRACT:
    1054       case CLASS_FINAL:
    1055       case CLASS_NOT:
    1056       case CLASS_PATTERN:
    1057         ClassPattern();
    1058         break;
    1059       default:
    1060         jj_la1[19] = jj_gen;
    1061         ;
    1062       }
    1063       jj_consume_token(CLASS_POINTCUT_END);
    1064     } catch (Throwable jjte000) {
    1065       if (jjtc000) {
    1066         jjtree.clearNodeScope(jjtn000);
    1067         jjtc000 = false;
    1068       } else {
    1069         jjtree.popNode();
    1070       }
    1071       if (jjte000 instanceof RuntimeException) {
    1072         {if (true) throw (RuntimeException)jjte000;}
    1073       }
    1074       if (jjte000 instanceof ParseException) {
    1075         {if (true) throw (ParseException)jjte000;}
    1076       }
    1077       {if (true) throw (Error)jjte000;}
    1078     } finally {
    1079       if (jjtc000) {
    1080         jjtree.closeNodeScope(jjtn000, true);
    1081       }
    1082     }
    1083   }
    1084
    1085 /***
    1086  * Cflow.
    1087  */
    1088   static final public void Cflow() throws ParseException {
    1089                        /*@bgen(jjtree) Cflow */
    1090   ASTCflow jjtn000 = new ASTCflow(JJTCFLOW);
    1091   boolean jjtc000 = true;
    1092   jjtree.openNodeScope(jjtn000);
    1093     try {
    1094       jj_consume_token(CFLOW);
    1095       Expression();
    1096       jj_consume_token(87);
    1097     } catch (Throwable jjte000) {
    1098      if (jjtc000) {
    1099        jjtree.clearNodeScope(jjtn000);
    1100        jjtc000 = false;
    1101      } else {
    1102        jjtree.popNode();
    1103      }
    1104      if (jjte000 instanceof RuntimeException) {
    1105        {if (true) throw (RuntimeException)jjte000;}
    1106      }
    1107      if (jjte000 instanceof ParseException) {
    1108        {if (true) throw (ParseException)jjte000;}
    1109      }
    1110      {if (true) throw (Error)jjte000;}
    1111     } finally {
    1112      if (jjtc000) {
    1113        jjtree.closeNodeScope(jjtn000, true);
    1114      }
    1115     }
    1116   }
    1117
    1118 /***
    1119  * CflowBelow.
    1120  */
    1121   static final public void CflowBelow() throws ParseException {
    1122                                  /*@bgen(jjtree) CflowBelow */
    1123   ASTCflowBelow jjtn000 = new ASTCflowBelow(JJTCFLOWBELOW);
    1124   boolean jjtc000 = true;
    1125   jjtree.openNodeScope(jjtn000);
    1126     try {
    1127       jj_consume_token(CFLOW_BELOW);
    1128       Expression();
    1129       jj_consume_token(87);
    1130     } catch (Throwable jjte000) {
    1131      if (jjtc000) {
    1132        jjtree.clearNodeScope(jjtn000);
    1133        jjtc000 = false;
    1134      } else {
    1135        jjtree.popNode();
    1136      }
    1137      if (jjte000 instanceof RuntimeException) {
    1138        {if (true) throw (RuntimeException)jjte000;}
    1139      }
    1140      if (jjte000 instanceof ParseException) {
    1141        {if (true) throw (ParseException)jjte000;}
    1142      }
    1143      {if (true) throw (Error)jjte000;}
    1144     } finally {
    1145      if (jjtc000) {
    1146        jjtree.closeNodeScope(jjtn000, true);
    1147      }
    1148     }
    1149   }
    1150
    1151 /***
    1152  * Args.
    1153  */
    1154   static final public void Args() throws ParseException {
    1155                      /*@bgen(jjtree) Args */
    1156   ASTArgs jjtn000 = new ASTArgs(JJTARGS);
    1157   boolean jjtc000 = true;
    1158   jjtree.openNodeScope(jjtn000);
    1159     try {
    1160       if (jj_2_14(2)) {
    1161         jj_consume_token(ARGS);
    1162         jj_consume_token(ARGS_END);
    1163       } else {
    1164         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1165         case ARGS:
    1166           jj_consume_token(ARGS);
    1167           ArgsParameters();
    1168           jj_consume_token(ARGS_END);
    1169           break;
    1170         default:
    1171           jj_la1[20] = jj_gen;
    1172           jj_consume_token(-1);
    1173           throw new ParseException();
    1174         }
    1175       }
    1176     } catch (Throwable jjte000) {
    1177       if (jjtc000) {
    1178         jjtree.clearNodeScope(jjtn000);
    1179         jjtc000 = false;
    1180       } else {
    1181         jjtree.popNode();
    1182       }
    1183       if (jjte000 instanceof RuntimeException) {
    1184         {if (true) throw (RuntimeException)jjte000;}
    1185       }
    1186       if (jjte000 instanceof ParseException) {
    1187         {if (true) throw (ParseException)jjte000;}
    1188       }
    1189       {if (true) throw (Error)jjte000;}
    1190     } finally {
    1191       if (jjtc000) {
    1192         jjtree.closeNodeScope(jjtn000, true);
    1193       }
    1194     }
    1195   }
    1196
    1197 /***
    1198  * HasMethod.
    1199  */
    1200   static final public void HasMethod() throws ParseException {
    1201                                /*@bgen(jjtree) HasMethod */
    1202   ASTHasMethod jjtn000 = new ASTHasMethod(JJTHASMETHOD);
    1203   boolean jjtc000 = true;
    1204   jjtree.openNodeScope(jjtn000);
    1205     try {
    1206       jj_consume_token(HAS_METHOD);
    1207       label_12:
    1208       while (true) {
    1209         if (jj_2_15(2)) {
    1210           ;
    1211         } else {
    1212           break label_12;
    1213         }
    1214         MethodAttribute();
    1215       }
    1216       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1217       case METHOD_PARAMETER_END:
    1218         jj_consume_token(METHOD_PARAMETER_END);
    1219         break;
    1220       case METHOD_PUBLIC:
    1221       case METHOD_PROTECTED:
    1222       case METHOD_PRIVATE:
    1223       case METHOD_STATIC:
    1224       case METHOD_ABSTRACT:
    1225       case METHOD_FINAL:
    1226       case METHOD_NATIVE:
    1227       case METHOD_SYNCHRONIZED:
    1228       case METHOD_NOT:
    1229       case METHOD_CLASS_PATTERN:
    1230       case METHOD_ARRAY_CLASS_PATTERN:
    1231       case 87:
    1232         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1233         case METHOD_PUBLIC:
    1234         case METHOD_PROTECTED:
    1235         case METHOD_PRIVATE:
    1236         case METHOD_STATIC:
    1237         case METHOD_ABSTRACT:
    1238         case METHOD_FINAL:
    1239         case METHOD_NATIVE:
    1240         case METHOD_SYNCHRONIZED:
    1241         case METHOD_NOT:
    1242         case METHOD_CLASS_PATTERN:
    1243         case METHOD_ARRAY_CLASS_PATTERN:
    1244           if (jj_2_16(4)) {
    1245             ConstructorPattern();
    1246           } else {
    1247             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1248             case METHOD_PUBLIC:
    1249             case METHOD_PROTECTED:
    1250             case METHOD_PRIVATE:
    1251             case METHOD_STATIC:
    1252             case METHOD_ABSTRACT:
    1253             case METHOD_FINAL:
    1254             case METHOD_NATIVE:
    1255             case METHOD_SYNCHRONIZED:
    1256             case METHOD_NOT:
    1257             case METHOD_CLASS_PATTERN:
    1258             case METHOD_ARRAY_CLASS_PATTERN:
    1259               MethodPattern();
    1260               break;
    1261             default:
    1262               jj_la1[21] = jj_gen;
    1263               jj_consume_token(-1);
    1264               throw new ParseException();
    1265             }
    1266           }
    1267           break;
    1268         default:
    1269           jj_la1[22] = jj_gen;
    1270           ;
    1271         }
    1272         jj_consume_token(87);
    1273         break;
    1274       default:
    1275         jj_la1[23] = jj_gen;
    1276         jj_consume_token(-1);
    1277         throw new ParseException();
    1278       }
    1279     } catch (Throwable jjte000) {
    1280           if (jjtc000) {
    1281             jjtree.clearNodeScope(jjtn000);
    1282             jjtc000 = false;
    1283           } else {
    1284             jjtree.popNode();
    1285           }
    1286           if (jjte000 instanceof RuntimeException) {
    1287             {if (true) throw (RuntimeException)jjte000;}
    1288           }
    1289           if (jjte000 instanceof ParseException) {
    1290             {if (true) throw (ParseException)jjte000;}
    1291           }
    1292           {if (true) throw (Error)jjte000;}
    1293     } finally {
    1294           if (jjtc000) {
    1295             jjtree.closeNodeScope(jjtn000, true);
    1296           }
    1297     }
    1298   }
    1299
    1300 /***
    1301  * HasField.
    1302  */
    1303   static final public void HasField() throws ParseException {
    1304                              /*@bgen(jjtree) HasField */
    1305   ASTHasField jjtn000 = new ASTHasField(JJTHASFIELD);
    1306   boolean jjtc000 = true;
    1307   jjtree.openNodeScope(jjtn000);
    1308     try {
    1309       jj_consume_token(HAS_FIELD);
    1310       label_13:
    1311       while (true) {
    1312         if (jj_2_17(2)) {
    1313           ;
    1314         } else {
    1315           break label_13;
    1316         }
    1317         FieldAttribute();
    1318       }
    1319       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1320       case FIELD_PRIVATE:
    1321       case FIELD_PROTECTED:
    1322       case FIELD_PUBLIC:
    1323       case FIELD_STATIC:
    1324       case FIELD_ABSTRACT:
    1325       case FIELD_FINAL:
    1326       case FIELD_TRANSIENT:
    1327       case FIELD_NOT:
    1328       case FIELD_CLASS_PATTERN:
    1329       case FIELD_ARRAY_CLASS_PATTERN:
    1330         FieldPattern();
    1331         break;
    1332       default:
    1333         jj_la1[24] = jj_gen;
    1334         ;
    1335       }
    1336       jj_consume_token(FIELD_POINTCUT_END);
    1337     } catch (Throwable jjte000) {
    1338      if (jjtc000) {
    1339        jjtree.clearNodeScope(jjtn000);
    1340        jjtc000 = false;
    1341      } else {
    1342        jjtree.popNode();
    1343      }
    1344      if (jjte000 instanceof RuntimeException) {
    1345        {if (true) throw (RuntimeException)jjte000;}
    1346      }
    1347      if (jjte000 instanceof ParseException) {
    1348        {if (true) throw (ParseException)jjte000;}
    1349      }
    1350      {if (true) throw (Error)jjte000;}
    1351     } finally {
    1352      if (jjtc000) {
    1353        jjtree.closeNodeScope(jjtn000, true);
    1354      }
    1355     }
    1356   }
    1357
    1358 /***
    1359  * Target
    1360  */
    1361   static final public void Target() throws ParseException {
    1362  /*@bgen(jjtree) Target */
    1363     ASTTarget jjtn000 = new ASTTarget(JJTTARGET);
    1364     boolean jjtc000 = true;
    1365     jjtree.openNodeScope(jjtn000);Token identifier;
    1366     try {
    1367       jj_consume_token(TARGET);
    1368       identifier = jj_consume_token(CLASS_PATTERN);
    1369         jjtn000.setIdentifier(identifier.image);
    1370       jj_consume_token(CLASS_POINTCUT_END);
    1371     } finally {
    1372       if (jjtc000) {
    1373         jjtree.closeNodeScope(jjtn000, true);
    1374       }
    1375     }
    1376   }
    1377
    1378 /***
    1379  * This
    1380  */
    1381   static final public void This() throws ParseException {
    1382  /*@bgen(jjtree) This */
    1383     ASTThis jjtn000 = new ASTThis(JJTTHIS);
    1384     boolean jjtc000 = true;
    1385     jjtree.openNodeScope(jjtn000);Token identifier;
    1386     try {
    1387       jj_consume_token(THIS);
    1388       identifier = jj_consume_token(CLASS_PATTERN);
    1389         jjtn000.setIdentifier(identifier.image);
    1390       jj_consume_token(CLASS_POINTCUT_END);
    1391     } finally {
    1392       if (jjtc000) {
    1393         jjtree.closeNodeScope(jjtn000, true);
    1394       }
    1395     }
    1396   }
    1397
    1398 //------------------ Patterns ------------------
    1399
    1400 /***
    1401  * Class pattern.
    1402  */
    1403   static final public void ClassPattern() throws ParseException {
    1404  /*@bgen(jjtree) ClassPattern */
    1405     ASTClassPattern jjtn000 = new ASTClassPattern(JJTCLASSPATTERN);
    1406     boolean jjtc000 = true;
    1407     jjtree.openNodeScope(jjtn000);Token pattern;
    1408     try {
    1409       label_14:
    1410       while (true) {
    1411         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1412         case CLASS_PRIVATE:
    1413         case CLASS_PROTECTED:
    1414         case CLASS_PUBLIC:
    1415         case CLASS_STATIC:
    1416         case CLASS_ABSTRACT:
    1417         case CLASS_FINAL:
    1418         case CLASS_NOT:
    1419           ;
    1420           break;
    1421         default:
    1422           jj_la1[25] = jj_gen;
    1423           break label_14;
    1424         }
    1425         ClassModifier();
    1426       }
    1427       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1428       case CLASS_PATTERN:
    1429         pattern = jj_consume_token(CLASS_PATTERN);
    1430         break;
    1431       case EAGER_WILDCARD:
    1432         pattern = jj_consume_token(EAGER_WILDCARD);
    1433         break;
    1434       default:
    1435         jj_la1[26] = jj_gen;
    1436         jj_consume_token(-1);
    1437         throw new ParseException();
    1438       }
    1439       jjtree.closeNodeScope(jjtn000, true);
    1440       jjtc000 = false;
    1441         jjtn000.setTypePattern(pattern.image);
    1442     } catch (Throwable jjte000) {
    1443       if (jjtc000) {
    1444         jjtree.clearNodeScope(jjtn000);
    1445         jjtc000 = false;
    1446       } else {
    1447         jjtree.popNode();
    1448       }
    1449       if (jjte000 instanceof RuntimeException) {
    1450         {if (true) throw (RuntimeException)jjte000;}
    1451       }
    1452       if (jjte000 instanceof ParseException) {
    1453         {if (true) throw (ParseException)jjte000;}
    1454       }
    1455       {if (true) throw (Error)jjte000;}
    1456     } finally {
    1457       if (jjtc000) {
    1458         jjtree.closeNodeScope(jjtn000, true);
    1459       }
    1460     }
    1461   }
    1462
    1463 /***
    1464  * Method pattern.
    1465  *
    1466  * @TODO: split class name and method name.
    1467  * @TODO: handle '+'.
    1468  * @TODO: put method name, return type and declaring class in different nodes.
    1469  */
    1470   static final public void MethodPattern() throws ParseException {
    1471  /*@bgen(jjtree) MethodPattern */
    1472     ASTMethodPattern jjtn000 = new ASTMethodPattern(JJTMETHODPATTERN);
    1473     boolean jjtc000 = true;
    1474     jjtree.openNodeScope(jjtn000);Token returnType, name;
    1475     try {
    1476       label_15:
    1477       while (true) {
    1478         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1479         case METHOD_PUBLIC:
    1480         case METHOD_PROTECTED:
    1481         case METHOD_PRIVATE:
    1482         case METHOD_STATIC:
    1483         case METHOD_ABSTRACT:
    1484         case METHOD_FINAL:
    1485         case METHOD_NATIVE:
    1486         case METHOD_SYNCHRONIZED:
    1487         case METHOD_NOT:
    1488           ;
    1489           break;
    1490         default:
    1491           jj_la1[27] = jj_gen;
    1492           break label_15;
    1493         }
    1494         MethodModifier();
    1495       }
    1496       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1497       case METHOD_CLASS_PATTERN:
    1498         returnType = jj_consume_token(METHOD_CLASS_PATTERN);
    1499         break;
    1500       case METHOD_ARRAY_CLASS_PATTERN:
    1501         returnType = jj_consume_token(METHOD_ARRAY_CLASS_PATTERN);
    1502         break;
    1503       default:
    1504         jj_la1[28] = jj_gen;
    1505         jj_consume_token(-1);
    1506         throw new ParseException();
    1507       }
    1508                 jjtn000.setReturnTypePattern(returnType.image);
    1509       name = jj_consume_token(METHOD_CLASS_PATTERN);
    1510                 jjtn000.setFullNamePattern(name.image);
    1511       Parameters();
    1512     } catch (Throwable jjte000) {
    1513               if (jjtc000) {
    1514                 jjtree.clearNodeScope(jjtn000);
    1515                 jjtc000 = false;
    1516               } else {
    1517                 jjtree.popNode();
    1518               }
    1519               if (jjte000 instanceof RuntimeException) {
    1520                 {if (true) throw (RuntimeException)jjte000;}
    1521               }
    1522               if (jjte000 instanceof ParseException) {
    1523                 {if (true) throw (ParseException)jjte000;}
    1524               }
    1525               {if (true) throw (Error)jjte000;}
    1526     } finally {
    1527               if (jjtc000) {
    1528                 jjtree.closeNodeScope(jjtn000, true);
    1529               }
    1530     }
    1531   }
    1532
    1533 /***
    1534  * Constructor pattern.
    1535  *
    1536  * @TODO: split class name and constructor name ('new').
    1537  * @TODO: handle '+'.
    1538  * @TODO: put declaring class in a different node.
    1539  */
    1540   static final public void ConstructorPattern() throws ParseException {
    1541  /*@bgen(jjtree) ConstructorPattern */
    1542     ASTConstructorPattern jjtn000 = new ASTConstructorPattern(JJTCONSTRUCTORPATTERN);
    1543     boolean jjtc000 = true;
    1544     jjtree.openNodeScope(jjtn000);Token name;
    1545     try {
    1546       label_16:
    1547       while (true) {
    1548         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1549         case METHOD_PUBLIC:
    1550         case METHOD_PROTECTED:
    1551         case METHOD_PRIVATE:
    1552         case METHOD_SYNCHRONIZED:
    1553         case METHOD_NOT:
    1554           ;
    1555           break;
    1556         default:
    1557           jj_la1[29] = jj_gen;
    1558           break label_16;
    1559         }
    1560         ConstructorModifier();
    1561       }
    1562       name = jj_consume_token(METHOD_CLASS_PATTERN);
    1563         if (!name.image.endsWith("new")) {
    1564             {if (true) throw new RuntimeException("constructor pattern must have 'new' as method name");}
    1565         }
    1566         jjtn000.setFullNamePattern(name.image);
    1567       Parameters();
    1568     } catch (Throwable jjte000) {
    1569       if (jjtc000) {
    1570         jjtree.clearNodeScope(jjtn000);
    1571         jjtc000 = false;
    1572       } else {
    1573         jjtree.popNode();
    1574       }
    1575       if (jjte000 instanceof RuntimeException) {
    1576         {if (true) throw (RuntimeException)jjte000;}
    1577       }
    1578       if (jjte000 instanceof ParseException) {
    1579         {if (true) throw (ParseException)jjte000;}
    1580       }
    1581       {if (true) throw (Error)jjte000;}
    1582     } finally {
    1583       if (jjtc000) {
    1584         jjtree.closeNodeScope(jjtn000, true);
    1585       }
    1586     }
    1587   }
    1588
    1589 /***
    1590  * Field pattern.
    1591  *
    1592  * @TODO: split class name and field name.
    1593  * @TODO: handle '+'.
    1594  * @TODO: put field name, field type and declaring class in different nodes.
    1595  */
    1596   static final public void FieldPattern() throws ParseException {
    1597  /*@bgen(jjtree) FieldPattern */
    1598     ASTFieldPattern jjtn000 = new ASTFieldPattern(JJTFIELDPATTERN);
    1599     boolean jjtc000 = true;
    1600     jjtree.openNodeScope(jjtn000);Token type, name;
    1601     try {
    1602       label_17:
    1603       while (true) {
    1604         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1605         case FIELD_PRIVATE:
    1606         case FIELD_PROTECTED:
    1607         case FIELD_PUBLIC:
    1608         case FIELD_STATIC:
    1609         case FIELD_ABSTRACT:
    1610         case FIELD_FINAL:
    1611         case FIELD_TRANSIENT:
    1612         case FIELD_NOT:
    1613           ;
    1614           break;
    1615         default:
    1616           jj_la1[30] = jj_gen;
    1617           break label_17;
    1618         }
    1619         FieldModifier();
    1620       }
    1621       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1622       case FIELD_CLASS_PATTERN:
    1623         type = jj_consume_token(FIELD_CLASS_PATTERN);
    1624         break;
    1625       case FIELD_ARRAY_CLASS_PATTERN:
    1626         type = jj_consume_token(FIELD_ARRAY_CLASS_PATTERN);
    1627         break;
    1628       default:
    1629         jj_la1[31] = jj_gen;
    1630         jj_consume_token(-1);
    1631         throw new ParseException();
    1632       }
    1633         jjtn000.setFieldTypePattern(type.image);
    1634       name = jj_consume_token(FIELD_CLASS_PATTERN);
    1635       jjtree.closeNodeScope(jjtn000, true);
    1636       jjtc000 = false;
    1637         jjtn000.setFullNamePattern(name.image);
    1638     } catch (Throwable jjte000) {
    1639       if (jjtc000) {
    1640         jjtree.clearNodeScope(jjtn000);
    1641         jjtc000 = false;
    1642       } else {
    1643         jjtree.popNode();
    1644       }
    1645       if (jjte000 instanceof RuntimeException) {
    1646         {if (true) throw (RuntimeException)jjte000;}
    1647       }
    1648       if (jjte000 instanceof ParseException) {
    1649         {if (true) throw (ParseException)jjte000;}
    1650       }
    1651       {if (true) throw (Error)jjte000;}
    1652     } finally {
    1653       if (jjtc000) {
    1654         jjtree.closeNodeScope(jjtn000, true);
    1655       }
    1656     }
    1657   }
    1658
    1659 /***
    1660  * Parameters.
    1661  */
    1662   static final public void Parameters() throws ParseException {
    1663     jj_consume_token(METHOD_PARAMETER_START);
    1664     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1665     case EAGER_WILDCARD:
    1666     case METHOD_CLASS_PATTERN:
    1667     case METHOD_ARRAY_CLASS_PATTERN:
    1668       Parameter();
    1669       label_18:
    1670       while (true) {
    1671         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1672         case COMMA:
    1673           ;
    1674           break;
    1675         default:
    1676           jj_la1[32] = jj_gen;
    1677           break label_18;
    1678         }
    1679         jj_consume_token(COMMA);
    1680         Parameter();
    1681       }
    1682       break;
    1683     default:
    1684       jj_la1[33] = jj_gen;
    1685       ;
    1686     }
    1687     jj_consume_token(METHOD_PARAMETER_END);
    1688   }
    1689
    1690 /***
    1691  * Parameter pattern.
    1692  */
    1693   static final public void Parameter() throws ParseException {
    1694  /*@bgen(jjtree) Parameter */
    1695     ASTParameter jjtn000 = new ASTParameter(JJTPARAMETER);
    1696     boolean jjtc000 = true;
    1697     jjtree.openNodeScope(jjtn000);Token parameter;
    1698     try {
    1699       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1700       case METHOD_CLASS_PATTERN:
    1701         parameter = jj_consume_token(METHOD_CLASS_PATTERN);
    1702         break;
    1703       case METHOD_ARRAY_CLASS_PATTERN:
    1704         parameter = jj_consume_token(METHOD_ARRAY_CLASS_PATTERN);
    1705         break;
    1706       case EAGER_WILDCARD:
    1707         parameter = jj_consume_token(EAGER_WILDCARD);
    1708         break;
    1709       default:
    1710         jj_la1[34] = jj_gen;
    1711         jj_consume_token(-1);
    1712         throw new ParseException();
    1713       }
    1714       jjtree.closeNodeScope(jjtn000, true);
    1715       jjtc000 = false;
    1716         jjtn000.setTypePattern(parameter.image);
    1717     } finally {
    1718       if (jjtc000) {
    1719         jjtree.closeNodeScope(jjtn000, true);
    1720       }
    1721     }
    1722   }
    1723
    1724 /***
    1725  * ArgsParameters.
    1726  */
    1727   static final public void ArgsParameters() throws ParseException {
    1728     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1729     case EAGER_WILDCARD:
    1730     case ARG_PATTERN:
    1731     case ARG_ARRAY_PATTERN:
    1732       ArgParameter();
    1733       break;
    1734     default:
    1735       jj_la1[35] = jj_gen;
    1736       ;
    1737     }
    1738     label_19:
    1739     while (true) {
    1740       if (jj_2_18(2)) {
    1741         ;
    1742       } else {
    1743         break label_19;
    1744       }
    1745       jj_consume_token(COMMA);
    1746       ArgsParameters();
    1747     }
    1748   }
    1749
    1750 /***
    1751  * ArgParameter.
    1752  */
    1753   static final public void ArgParameter() throws ParseException {
    1754  /*@bgen(jjtree) ArgParameter */
    1755     ASTArgParameter jjtn000 = new ASTArgParameter(JJTARGPARAMETER);
    1756     boolean jjtc000 = true;
    1757     jjtree.openNodeScope(jjtn000);Token t;
    1758     try {
    1759       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1760       case ARG_PATTERN:
    1761         t = jj_consume_token(ARG_PATTERN);
    1762         break;
    1763       case ARG_ARRAY_PATTERN:
    1764         t = jj_consume_token(ARG_ARRAY_PATTERN);
    1765         break;
    1766       case EAGER_WILDCARD:
    1767         t = jj_consume_token(EAGER_WILDCARD);
    1768         break;
    1769       default:
    1770         jj_la1[36] = jj_gen;
    1771         jj_consume_token(-1);
    1772         throw new ParseException();
    1773       }
    1774       jjtree.closeNodeScope(jjtn000, true);
    1775       jjtc000 = false;
    1776         jjtn000.setTypePattern(t.image);
    1777     } finally {
    1778       if (jjtc000) {
    1779         jjtree.closeNodeScope(jjtn000, true);
    1780       }
    1781     }
    1782   }
    1783
    1784 /***
    1785  * Class annotation.
    1786  */
    1787   static final public void ClassAttribute() throws ParseException {
    1788  /*@bgen(jjtree) Attribute */
    1789     ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
    1790     boolean jjtc000 = true;
    1791     jjtree.openNodeScope(jjtn000);Token annotation;
    1792     try {
    1793       label_20:
    1794       while (true) {
    1795         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1796         case CLASS_NOT:
    1797           ;
    1798           break;
    1799         default:
    1800           jj_la1[37] = jj_gen;
    1801           break label_20;
    1802         }
    1803         jj_consume_token(CLASS_NOT);
    1804             jjtn000.toggleNot();
    1805       }
    1806       annotation = jj_consume_token(CLASS_ATTRIBUTE);
    1807       jjtree.closeNodeScope(jjtn000, true);
    1808       jjtc000 = false;
    1809         jjtn000.setName(annotation.image);
    1810     } finally {
    1811       if (jjtc000) {
    1812         jjtree.closeNodeScope(jjtn000, true);
    1813       }
    1814     }
    1815   }
    1816
    1817 /***
    1818  * Method annotation.
    1819  */
    1820   static final public void MethodAttribute() throws ParseException {
    1821  /*@bgen(jjtree) Attribute */
    1822     ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
    1823     boolean jjtc000 = true;
    1824     jjtree.openNodeScope(jjtn000);Token annotation;
    1825     try {
    1826       label_21:
    1827       while (true) {
    1828         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1829         case METHOD_NOT:
    1830           ;
    1831           break;
    1832         default:
    1833           jj_la1[38] = jj_gen;
    1834           break label_21;
    1835         }
    1836         jj_consume_token(METHOD_NOT);
    1837             jjtn000.toggleNot();
    1838       }
    1839       annotation = jj_consume_token(METHOD_ANNOTATION);
    1840       jjtree.closeNodeScope(jjtn000, true);
    1841       jjtc000 = false;
    1842         jjtn000.setName(annotation.image);
    1843     } finally {
    1844       if (jjtc000) {
    1845         jjtree.closeNodeScope(jjtn000, true);
    1846       }
    1847     }
    1848   }
    1849
    1850 /***
    1851  * Field annotation.
    1852  */
    1853   static final public void FieldAttribute() throws ParseException {
    1854  /*@bgen(jjtree) Attribute */
    1855     ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
    1856     boolean jjtc000 = true;
    1857     jjtree.openNodeScope(jjtn000);Token annotation;
    1858     try {
    1859       label_22:
    1860       while (true) {
    1861         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1862         case FIELD_NOT:
    1863           ;
    1864           break;
    1865         default:
    1866           jj_la1[39] = jj_gen;
    1867           break label_22;
    1868         }
    1869         jj_consume_token(FIELD_NOT);
    1870             jjtn000.toggleNot();
    1871       }
    1872       annotation = jj_consume_token(FIELD_ANNOTATION);
    1873       jjtree.closeNodeScope(jjtn000, true);
    1874       jjtc000 = false;
    1875         jjtn000.setName(annotation.image);
    1876     } finally {
    1877       if (jjtc000) {
    1878         jjtree.closeNodeScope(jjtn000, true);
    1879       }
    1880     }
    1881   }
    1882
    1883 /***
    1884  * Class modifier.
    1885  */
    1886   static final public void ClassModifier() throws ParseException {
    1887                                   /*@bgen(jjtree) Modifier */
    1888   ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
    1889   boolean jjtc000 = true;
    1890   jjtree.openNodeScope(jjtn000);
    1891     try {
    1892       label_23:
    1893       while (true) {
    1894         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1895         case CLASS_NOT:
    1896           ;
    1897           break;
    1898         default:
    1899           jj_la1[40] = jj_gen;
    1900           break label_23;
    1901         }
    1902         jj_consume_token(CLASS_NOT);
    1903         jjtn000.toggleNot();
    1904       }
    1905       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1906       case CLASS_PUBLIC:
    1907         jj_consume_token(CLASS_PUBLIC);
    1908       jjtree.closeNodeScope(jjtn000, true);
    1909       jjtc000 = false;
    1910         jjtn000.setModifier(Modifier.PUBLIC);
    1911         break;
    1912       case CLASS_PROTECTED:
    1913         jj_consume_token(CLASS_PROTECTED);
    1914       jjtree.closeNodeScope(jjtn000, true);
    1915       jjtc000 = false;
    1916         jjtn000.setModifier(Modifier.PROTECTED);
    1917         break;
    1918       case CLASS_PRIVATE:
    1919         jj_consume_token(CLASS_PRIVATE);
    1920       jjtree.closeNodeScope(jjtn000, true);
    1921       jjtc000 = false;
    1922         jjtn000.setModifier(Modifier.PRIVATE);
    1923         break;
    1924       case CLASS_STATIC:
    1925         jj_consume_token(CLASS_STATIC);
    1926       jjtree.closeNodeScope(jjtn000, true);
    1927       jjtc000 = false;
    1928         jjtn000.setModifier(Modifier.STATIC);
    1929         break;
    1930       case CLASS_ABSTRACT:
    1931         jj_consume_token(CLASS_ABSTRACT);
    1932       jjtree.closeNodeScope(jjtn000, true);
    1933       jjtc000 = false;
    1934         jjtn000.setModifier(Modifier.ABSTRACT);
    1935         break;
    1936       case CLASS_FINAL:
    1937         jj_consume_token(CLASS_FINAL);
    1938       jjtree.closeNodeScope(jjtn000, true);
    1939       jjtc000 = false;
    1940         jjtn000.setModifier(Modifier.FINAL);
    1941         break;
    1942       default:
    1943         jj_la1[41] = jj_gen;
    1944         jj_consume_token(-1);
    1945         throw new ParseException();
    1946       }
    1947     } finally {
    1948       if (jjtc000) {
    1949         jjtree.closeNodeScope(jjtn000, true);
    1950       }
    1951     }
    1952   }
    1953
    1954 /***
    1955  * Method modifier.
    1956  */
    1957   static final public void StaticInitializationPatternModifier() throws ParseException {
    1958                                                         /*@bgen(jjtree) Modifier */
    1959   ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
    1960   boolean jjtc000 = true;
    1961   jjtree.openNodeScope(jjtn000);
    1962     try {
    1963       label_24:
    1964       while (true) {
    1965         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1966         case METHOD_NOT:
    1967           ;
    1968           break;
    1969         default:
    1970           jj_la1[42] = jj_gen;
    1971           break label_24;
    1972         }
    1973         jj_consume_token(METHOD_NOT);
    1974         jjtn000.toggleNot();
    1975       }
    1976       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1977       case METHOD_PUBLIC:
    1978         jj_consume_token(METHOD_PUBLIC);
    1979       jjtree.closeNodeScope(jjtn000, true);
    1980       jjtc000 = false;
    1981         jjtn000.setModifier(Modifier.PUBLIC);
    1982         break;
    1983       case METHOD_PROTECTED:
    1984         jj_consume_token(METHOD_PROTECTED);
    1985       jjtree.closeNodeScope(jjtn000, true);
    1986       jjtc000 = false;
    1987         jjtn000.setModifier(Modifier.PROTECTED);
    1988         break;
    1989       case METHOD_PRIVATE:
    1990         jj_consume_token(METHOD_PRIVATE);
    1991       jjtree.closeNodeScope(jjtn000, true);
    1992       jjtc000 = false;
    1993         jjtn000.setModifier(Modifier.PRIVATE);
    1994         break;
    1995       case METHOD_STATIC:
    1996         jj_consume_token(METHOD_STATIC);
    1997       jjtree.closeNodeScope(jjtn000, true);
    1998       jjtc000 = false;
    1999         jjtn000.setModifier(Modifier.STATIC);
    2000         break;
    2001       case METHOD_ABSTRACT:
    2002         jj_consume_token(METHOD_ABSTRACT);
    2003       jjtree.closeNodeScope(jjtn000, true);
    2004       jjtc000 = false;
    2005         jjtn000.setModifier(Modifier.ABSTRACT);
    2006         break;
    2007       case METHOD_FINAL:
    2008         jj_consume_token(METHOD_FINAL);
    2009       jjtree.closeNodeScope(jjtn000, true);
    2010       jjtc000 = false;
    2011         jjtn000.setModifier(Modifier.FINAL);
    2012         break;
    2013       default:
    2014         jj_la1[43] = jj_gen;
    2015         jj_consume_token(-1);
    2016         throw new ParseException();
    2017       }
    2018     } finally {
    2019       if (jjtc000) {
    2020         jjtree.closeNodeScope(jjtn000, true);
    2021       }
    2022     }
    2023   }
    2024
    2025 /***
    2026  * Method modifier.
    2027  */
    2028   static final public void MethodModifier() throws ParseException {
    2029                                    /*@bgen(jjtree) Modifier */
    2030   ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
    2031   boolean jjtc000 = true;
    2032   jjtree.openNodeScope(jjtn000);
    2033     try {
    2034       label_25:
    2035       while (true) {
    2036         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2037         case METHOD_NOT:
    2038           ;
    2039           break;
    2040         default:
    2041           jj_la1[44] = jj_gen;
    2042           break label_25;
    2043         }
    2044         jj_consume_token(METHOD_NOT);
    2045         jjtn000.toggleNot();
    2046       }
    2047       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2048       case METHOD_PUBLIC:
    2049         jj_consume_token(METHOD_PUBLIC);
    2050       jjtree.closeNodeScope(jjtn000, true);
    2051       jjtc000 = false;
    2052         jjtn000.setModifier(Modifier.PUBLIC);
    2053         break;
    2054       case METHOD_PROTECTED:
    2055         jj_consume_token(METHOD_PROTECTED);
    2056       jjtree.closeNodeScope(jjtn000, true);
    2057       jjtc000 = false;
    2058         jjtn000.setModifier(Modifier.PROTECTED);
    2059         break;
    2060       case METHOD_PRIVATE:
    2061         jj_consume_token(METHOD_PRIVATE);
    2062       jjtree.closeNodeScope(jjtn000, true);
    2063       jjtc000 = false;
    2064         jjtn000.setModifier(Modifier.PRIVATE);
    2065         break;
    2066       case METHOD_STATIC:
    2067         jj_consume_token(METHOD_STATIC);
    2068       jjtree.closeNodeScope(jjtn000, true);
    2069       jjtc000 = false;
    2070         jjtn000.setModifier(Modifier.STATIC);
    2071         break;
    2072       case METHOD_ABSTRACT:
    2073         jj_consume_token(METHOD_ABSTRACT);
    2074       jjtree.closeNodeScope(jjtn000, true);
    2075       jjtc000 = false;
    2076         jjtn000.setModifier(Modifier.ABSTRACT);
    2077         break;
    2078       case METHOD_FINAL:
    2079         jj_consume_token(METHOD_FINAL);
    2080       jjtree.closeNodeScope(jjtn000, true);
    2081       jjtc000 = false;
    2082         jjtn000.setModifier(Modifier.FINAL);
    2083         break;
    2084       case METHOD_NATIVE:
    2085         jj_consume_token(METHOD_NATIVE);
    2086       jjtree.closeNodeScope(jjtn000, true);
    2087       jjtc000 = false;
    2088         jjtn000.setModifier(Modifier.NATIVE);
    2089         break;
    2090       case METHOD_SYNCHRONIZED:
    2091         jj_consume_token(METHOD_SYNCHRONIZED);
    2092       jjtree.closeNodeScope(jjtn000, true);
    2093       jjtc000 = false;
    2094         jjtn000.setModifier(Modifier.SYNCHRONIZED);
    2095         break;
    2096       default:
    2097         jj_la1[45] = jj_gen;
    2098         jj_consume_token(-1);
    2099         throw new ParseException();
    2100       }
    2101     } finally {
    2102       if (jjtc000) {
    2103         jjtree.closeNodeScope(jjtn000, true);
    2104       }
    2105     }
    2106   }
    2107
    2108 /***
    2109  * Constructor modifier.
    2110  */
    2111   static final public void ConstructorModifier() throws ParseException {
    2112                                         /*@bgen(jjtree) Modifier */
    2113   ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
    2114   boolean jjtc000 = true;
    2115   jjtree.openNodeScope(jjtn000);
    2116     try {
    2117       label_26:
    2118       while (true) {
    2119         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2120         case METHOD_NOT:
    2121           ;
    2122           break;
    2123         default:
    2124           jj_la1[46] = jj_gen;
    2125           break label_26;
    2126         }
    2127         jj_consume_token(METHOD_NOT);
    2128         jjtn000.toggleNot();
    2129       }
    2130       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2131       case METHOD_PUBLIC:
    2132         jj_consume_token(METHOD_PUBLIC);
    2133       jjtree.closeNodeScope(jjtn000, true);
    2134       jjtc000 = false;
    2135         jjtn000.setModifier(Modifier.PUBLIC);
    2136         break;
    2137       case METHOD_PROTECTED:
    2138         jj_consume_token(METHOD_PROTECTED);
    2139       jjtree.closeNodeScope(jjtn000, true);
    2140       jjtc000 = false;
    2141         jjtn000.setModifier(Modifier.PROTECTED);
    2142         break;
    2143       case METHOD_PRIVATE:
    2144         jj_consume_token(METHOD_PRIVATE);
    2145       jjtree.closeNodeScope(jjtn000, true);
    2146       jjtc000 = false;
    2147         jjtn000.setModifier(Modifier.PRIVATE);
    2148         break;
    2149       case METHOD_SYNCHRONIZED:
    2150         jj_consume_token(METHOD_SYNCHRONIZED);
    2151       jjtree.closeNodeScope(jjtn000, true);
    2152       jjtc000 = false;
    2153         jjtn000.setModifier(Modifier.SYNCHRONIZED);
    2154         break;
    2155       default:
    2156         jj_la1[47] = jj_gen;
    2157         jj_consume_token(-1);
    2158         throw new ParseException();
    2159       }
    2160     } finally {
    2161       if (jjtc000) {
    2162         jjtree.closeNodeScope(jjtn000, true);
    2163       }
    2164     }
    2165   }
    2166
    2167 /***
    2168  * Field modifier.
    2169  */
    2170   static final public void FieldModifier() throws ParseException {
    2171                                   /*@bgen(jjtree) Modifier */
    2172   ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
    2173   boolean jjtc000 = true;
    2174   jjtree.openNodeScope(jjtn000);
    2175     try {
    2176       label_27:
    2177       while (true) {
    2178         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2179         case FIELD_NOT:
    2180           ;
    2181           break;
    2182         default:
    2183           jj_la1[48] = jj_gen;
    2184           break label_27;
    2185         }
    2186         jj_consume_token(FIELD_NOT);
    2187         jjtn000.toggleNot();
    2188       }
    2189       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2190       case FIELD_PUBLIC:
    2191         jj_consume_token(FIELD_PUBLIC);
    2192       jjtree.closeNodeScope(jjtn000, true);
    2193       jjtc000 = false;
    2194         jjtn000.setModifier(Modifier.PUBLIC);
    2195         break;
    2196       case FIELD_PROTECTED:
    2197         jj_consume_token(FIELD_PROTECTED);
    2198       jjtree.closeNodeScope(jjtn000, true);
    2199       jjtc000 = false;
    2200         jjtn000.setModifier(Modifier.PROTECTED);
    2201         break;
    2202       case FIELD_PRIVATE:
    2203         jj_consume_token(FIELD_PRIVATE);
    2204       jjtree.closeNodeScope(jjtn000, true);
    2205       jjtc000 = false;
    2206         jjtn000.setModifier(Modifier.PRIVATE);
    2207         break;
    2208       case FIELD_STATIC:
    2209         jj_consume_token(FIELD_STATIC);
    2210       jjtree.closeNodeScope(jjtn000, true);
    2211       jjtc000 = false;
    2212         jjtn000.setModifier(Modifier.STATIC);
    2213         break;
    2214       case FIELD_ABSTRACT:
    2215         jj_consume_token(FIELD_ABSTRACT);
    2216       jjtree.closeNodeScope(jjtn000, true);
    2217       jjtc000 = false;
    2218         jjtn000.setModifier(Modifier.ABSTRACT);
    2219         break;
    2220       case FIELD_FINAL:
    2221         jj_consume_token(FIELD_FINAL);
    2222       jjtree.closeNodeScope(jjtn000, true);
    2223       jjtc000 = false;
    2224         jjtn000.setModifier(Modifier.FINAL);
    2225         break;
    2226       case FIELD_TRANSIENT:
    2227         jj_consume_token(FIELD_TRANSIENT);
    2228       jjtree.closeNodeScope(jjtn000, true);
    2229       jjtc000 = false;
    2230         jjtn000.setModifier(Modifier.TRANSIENT);
    2231         break;
    2232       default:
    2233         jj_la1[49] = jj_gen;
    2234         jj_consume_token(-1);
    2235         throw new ParseException();
    2236       }
    2237     } finally {
    2238       if (jjtc000) {
    2239         jjtree.closeNodeScope(jjtn000, true);
    2240       }
    2241     }
    2242   }
    2243
    2244   static final private boolean jj_2_1(int xla) {
    2245     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2246     try { return !jj_3_1(); }
    2247     catch(LookaheadSuccess ls) { return true; }
    2248     finally { jj_save(0, xla); }
    2249   }
    2250
    2251   static final private boolean jj_2_2(int xla) {
    2252     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2253     try { return !jj_3_2(); }
    2254     catch(LookaheadSuccess ls) { return true; }
    2255     finally { jj_save(1, xla); }
    2256   }
    2257
    2258   static final private boolean jj_2_3(int xla) {
    2259     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2260     try { return !jj_3_3(); }
    2261     catch(LookaheadSuccess ls) { return true; }
    2262     finally { jj_save(2, xla); }
    2263   }
    2264
    2265   static final private boolean jj_2_4(int xla) {
    2266     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2267     try { return !jj_3_4(); }
    2268     catch(LookaheadSuccess ls) { return true; }
    2269     finally { jj_save(3, xla); }
    2270   }
    2271
    2272   static final private boolean jj_2_5(int xla) {
    2273     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2274     try { return !jj_3_5(); }
    2275     catch(LookaheadSuccess ls) { return true; }
    2276     finally { jj_save(4, xla); }
    2277   }
    2278
    2279   static final private boolean jj_2_6(int xla) {
    2280     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2281     try { return !jj_3_6(); }
    2282     catch(LookaheadSuccess ls) { return true; }
    2283     finally { jj_save(5, xla); }
    2284   }
    2285
    2286   static final private boolean jj_2_7(int xla) {
    2287     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2288     try { return !jj_3_7(); }
    2289     catch(LookaheadSuccess ls) { return true; }
    2290     finally { jj_save(6, xla); }
    2291   }
    2292
    2293   static final private boolean jj_2_8(int xla) {
    2294     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2295     try { return !jj_3_8(); }
    2296     catch(LookaheadSuccess ls) { return true; }
    2297     finally { jj_save(7, xla); }
    2298   }
    2299
    2300   static final private boolean jj_2_9(int xla) {
    2301     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2302     try { return !jj_3_9(); }
    2303     catch(LookaheadSuccess ls) { return true; }
    2304     finally { jj_save(8, xla); }
    2305   }
    2306
    2307   static final private boolean jj_2_10(int xla) {
    2308     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2309     try { return !jj_3_10(); }
    2310     catch(LookaheadSuccess ls) { return true; }
    2311     finally { jj_save(9, xla); }
    2312   }
    2313
    2314   static final private boolean jj_2_11(int xla) {
    2315     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2316     try { return !jj_3_11(); }
    2317     catch(LookaheadSuccess ls) { return true; }
    2318     finally { jj_save(10, xla); }
    2319   }
    2320
    2321   static final private boolean jj_2_12(int xla) {
    2322     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2323     try { return !jj_3_12(); }
    2324     catch(LookaheadSuccess ls) { return true; }
    2325     finally { jj_save(11, xla); }
    2326   }
    2327
    2328   static final private boolean jj_2_13(int xla) {
    2329     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2330     try { return !jj_3_13(); }
    2331     catch(LookaheadSuccess ls) { return true; }
    2332     finally { jj_save(12, xla); }
    2333   }
    2334
    2335   static final private boolean jj_2_14(int xla) {
    2336     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2337     try { return !jj_3_14(); }
    2338     catch(LookaheadSuccess ls) { return true; }
    2339     finally { jj_save(13, xla); }
    2340   }
    2341
    2342   static final private boolean jj_2_15(int xla) {
    2343     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2344     try { return !jj_3_15(); }
    2345     catch(LookaheadSuccess ls) { return true; }
    2346     finally { jj_save(14, xla); }
    2347   }
    2348
    2349   static final private boolean jj_2_16(int xla) {
    2350     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2351     try { return !jj_3_16(); }
    2352     catch(LookaheadSuccess ls) { return true; }
    2353     finally { jj_save(15, xla); }
    2354   }
    2355
    2356   static final private boolean jj_2_17(int xla) {
    2357     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2358     try { return !jj_3_17(); }
    2359     catch(LookaheadSuccess ls) { return true; }
    2360     finally { jj_save(16, xla); }
    2361   }
    2362
    2363   static final private boolean jj_2_18(int xla) {
    2364     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2365     try { return !jj_3_18(); }
    2366     catch(LookaheadSuccess ls) { return true; }
    2367     finally { jj_save(17, xla); }
    2368   }
    2369
    2370   static final private boolean jj_3_18() {
    2371     if (jj_scan_token(COMMA)) return true;
    2372     if (jj_3R_34()) return true;
    2373     return false;
    2374   }
    2375
    2376   static final private boolean jj_3R_56() {
    2377     if (jj_scan_token(COMMA)) return true;
    2378     return false;
    2379   }
    2380
    2381   static final private boolean jj_3R_76() {
    2382     if (jj_scan_token(HAS_METHOD)) return true;
    2383     return false;
    2384   }
    2385
    2386   static final private boolean jj_3_3() {
    2387     if (jj_3R_30()) return true;
    2388     return false;
    2389   }
    2390
    2391   static final private boolean jj_3_15() {
    2392     if (jj_3R_30()) return true;
    2393     return false;
    2394   }
    2395
    2396   static final private boolean jj_3R_74() {
    2397     if (jj_scan_token(EXECUTION)) return true;
    2398     return false;
    2399   }
    2400
    2401   static final private boolean jj_3R_47() {
    2402     Token xsp;
    2403     xsp = jj_scanpos;
    2404     if (jj_scan_token(82)) {
    2405     jj_scanpos = xsp;
    2406     if (jj_scan_token(83)) {
    2407     jj_scanpos = xsp;
    2408     if (jj_scan_token(7)) return true;
    2409     }
    2410     }
    2411     return false;
    2412   }
    2413
    2414   static final private boolean jj_3R_46() {
    2415     if (jj_3R_55()) return true;
    2416     Token xsp;
    2417     while (true) {
    2418       xsp = jj_scanpos;
    2419       if (jj_3R_56()) { jj_scanpos = xsp; break; }
    2420     }
    2421     return false;
    2422   }
    2423
    2424   static final private boolean jj_3R_89() {
    2425     if (jj_scan_token(ARGS)) return true;
    2426     return false;
    2427   }
    2428
    2429   static final private boolean jj_3R_41() {
    2430     if (jj_3R_47()) return true;
    2431     return false;
    2432   }
    2433
    2434   static final private boolean jj_3R_34() {
    2435     Token xsp;
    2436     xsp = jj_scanpos;
    2437     if (jj_3R_41()) jj_scanpos = xsp;
    2438     while (true) {
    2439       xsp = jj_scanpos;
    2440       if (jj_3_18()) { jj_scanpos = xsp; break; }
    2441     }
    2442     return false;
    2443   }
    2444
    2445   static final private boolean jj_3R_88() {
    2446     Token xsp;
    2447     xsp = jj_scanpos;
    2448     if (jj_scan_token(27)) {
    2449     jj_scanpos = xsp;
    2450     if (jj_scan_token(28)) return true;
    2451     }
    2452     return false;
    2453   }
    2454
    2455   static final private boolean jj_3R_82() {
    2456     Token xsp;
    2457     xsp = jj_scanpos;
    2458     if (jj_3_14()) {
    2459     jj_scanpos = xsp;
    2460     if (jj_3R_89()) return true;
    2461     }
    2462     return false;
    2463   }
    2464
    2465   static final private boolean jj_3_14() {
    2466     if (jj_scan_token(ARGS)) return true;
    2467     if (jj_scan_token(ARGS_END)) return true;
    2468     return false;
    2469   }
    2470
    2471   static final private boolean jj_3R_71() {
    2472     if (jj_3R_87()) return true;
    2473     return false;
    2474   }
    2475
    2476   static final private boolean jj_3R_70() {
    2477     if (jj_3R_86()) return true;
    2478     return false;
    2479   }
    2480
    2481   static final private boolean jj_3R_69() {
    2482     if (jj_3R_85()) return true;
    2483     return false;
    2484   }
    2485
    2486   static final private boolean jj_3R_68() {
    2487     if (jj_3R_84()) return true;
    2488     return false;
    2489   }
    2490
    2491   static final private boolean jj_3R_72() {
    2492     if (jj_3R_88()) return true;
    2493     return false;
    2494   }
    2495
    2496   static final private boolean jj_3R_86() {
    2497     if (jj_scan_token(CFLOW_BELOW)) return true;
    2498     return false;
    2499   }
    2500
    2501   static final private boolean jj_3R_67() {
    2502     if (jj_3R_83()) return true;
    2503     return false;
    2504   }
    2505
    2506   static final private boolean jj_3R_55() {
    2507     Token xsp;
    2508     xsp = jj_scanpos;
    2509     if (jj_scan_token(54)) {
    2510     jj_scanpos = xsp;
    2511     if (jj_scan_token(55)) {
    2512     jj_scanpos = xsp;
    2513     if (jj_scan_token(7)) return true;
    2514     }
    2515     }
    2516     return false;
    2517   }
    2518
    2519   static final private boolean jj_3R_66() {
    2520     if (jj_3R_82()) return true;
    2521     return false;
    2522   }
    2523
    2524   static final private boolean jj_3R_65() {
    2525     if (jj_3R_81()) return true;
    2526     return false;
    2527   }
    2528
    2529   static final private boolean jj_3R_64() {
    2530     if (jj_3R_80()) return true;
    2531     return false;
    2532   }
    2533
    2534   static final private boolean jj_3R_85() {
    2535     if (jj_scan_token(CFLOW)) return true;
    2536     return false;
    2537   }
    2538
    2539   static final private boolean jj_3R_63() {
    2540     if (jj_3R_79()) return true;
    2541     return false;
    2542   }
    2543
    2544   static final private boolean jj_3R_44() {
    2545     if (jj_3R_49()) return true;
    2546     return false;
    2547   }
    2548
    2549   static final private boolean jj_3R_62() {
    2550     if (jj_3R_78()) return true;
    2551     return false;
    2552   }
    2553
    2554   static final private boolean jj_3R_61() {
    2555     if (jj_3R_77()) return true;
    2556     return false;
    2557   }
    2558
    2559   static final private boolean jj_3R_38() {
    2560     if (jj_scan_token(METHOD_PARAMETER_START)) return true;
    2561     Token xsp;
    2562     xsp = jj_scanpos;
    2563     if (jj_3R_46()) jj_scanpos = xsp;
    2564     if (jj_scan_token(METHOD_PARAMETER_END)) return true;
    2565     return false;
    2566   }
    2567
    2568   static final private boolean jj_3R_60() {
    2569     if (jj_3R_76()) return true;
    2570     return false;
    2571   }
    2572
    2573   static final private boolean jj_3R_59() {
    2574     if (jj_3R_75()) return true;
    2575     return false;
    2576   }
    2577
    2578   static final private boolean jj_3R_58() {
    2579     if (jj_3R_74()) return true;
    2580     return false;
    2581   }
    2582
    2583   static final private boolean jj_3_13() {
    2584     if (jj_3R_33()) return true;
    2585     return false;
    2586   }
    2587
    2588   static final private boolean jj_3R_87() {
    2589     if (jj_scan_token(STATIC_INITIALIZATION)) return true;
    2590     return false;
    2591   }
    2592
    2593   static final private boolean jj_3R_49() {
    2594     Token xsp;
    2595     xsp = jj_scanpos;
    2596     if (jj_3R_57()) {
    2597     jj_scanpos = xsp;
    2598     if (jj_3R_58()) {
    2599     jj_scanpos = xsp;
    2600     if (jj_3R_59()) {
    2601     jj_scanpos = xsp;
    2602     if (jj_3R_60()) {
    2603     jj_scanpos = xsp;
    2604     if (jj_3R_61()) {
    2605     jj_scanpos = xsp;
    2606     if (jj_3R_62()) {
    2607     jj_scanpos = xsp;
    2608     if (jj_3R_63()) {
    2609     jj_scanpos = xsp;
    2610     if (jj_3R_64()) {
    2611     jj_scanpos = xsp;
    2612     if (jj_3R_65()) {
    2613     jj_scanpos = xsp;
    2614     if (jj_3R_66()) {
    2615     jj_scanpos = xsp;
    2616     if (jj_3R_67()) {
    2617     jj_scanpos = xsp;
    2618     if (jj_3R_68()) {
    2619     jj_scanpos = xsp;
    2620     if (jj_3R_69()) {
    2621     jj_scanpos = xsp;
    2622     if (jj_3R_70()) {
    2623     jj_scanpos = xsp;
    2624     if (jj_3R_71()) {
    2625     jj_scanpos = xsp;
    2626     if (jj_3R_72()) return true;
    2627     }
    2628     }
    2629     }
    2630     }
    2631     }
    2632     }
    2633     }
    2634     }
    2635     }
    2636     }
    2637     }
    2638     }
    2639     }
    2640     }
    2641     }
    2642     return false;
    2643   }
    2644
    2645   static final private boolean jj_3R_57() {
    2646     if (jj_3R_73()) return true;
    2647     return false;
    2648   }
    2649
    2650   static final private boolean jj_3_11() {
    2651     if (jj_3R_31()) return true;
    2652     return false;
    2653   }
    2654
    2655   static final private boolean jj_3_12() {
    2656     if (jj_3R_30()) return true;
    2657     return false;
    2658   }
    2659
    2660   static final private boolean jj_3R_43() {
    2661     if (jj_scan_token(86)) return true;
    2662     return false;
    2663   }
    2664
    2665   static final private boolean jj_3_2() {
    2666     if (jj_scan_token(OR)) return true;
    2667     if (jj_3R_29()) return true;
    2668     return false;
    2669   }
    2670
    2671   static final private boolean jj_3R_48() {
    2672     if (jj_scan_token(NOT)) return true;
    2673     return false;
    2674   }
    2675
    2676   static final private boolean jj_3_1() {
    2677     if (jj_scan_token(AND)) return true;
    2678     if (jj_3R_28()) return true;
    2679     return false;
    2680   }
    2681
    2682   static final private boolean jj_3R_37() {
    2683     if (jj_3R_45()) return true;
    2684     return false;
    2685   }
    2686
    2687   static final private boolean jj_3R_42() {
    2688     if (jj_3R_48()) return true;
    2689     return false;
    2690   }
    2691
    2692   static final private boolean jj_3R_35() {
    2693     Token xsp;
    2694     xsp = jj_scanpos;
    2695     if (jj_3R_42()) {
    2696     jj_scanpos = xsp;
    2697     if (jj_3R_43()) {
    2698     jj_scanpos = xsp;
    2699     if (jj_3R_44()) return true;
    2700     }
    2701     }
    2702     return false;
    2703   }
    2704
    2705   static final private boolean jj_3R_31() {
    2706     Token xsp;
    2707     while (true) {
    2708       xsp = jj_scanpos;
    2709       if (jj_3R_37()) { jj_scanpos = xsp; break; }
    2710     }
    2711     if (jj_scan_token(METHOD_CLASS_PATTERN)) return true;
    2712     if (jj_3R_38()) return true;
    2713     return false;
    2714   }
    2715
    2716   static final private boolean jj_3_10() {
    2717     if (jj_3R_30()) return true;
    2718     return false;
    2719   }
    2720
    2721   static final private boolean jj_3R_28() {
    2722     if (jj_3R_35()) return true;
    2723     return false;
    2724   }
    2725
    2726   static final private boolean jj_3R_29() {
    2727     if (jj_3R_28()) return true;
    2728     return false;
    2729   }
    2730
    2731   static final private boolean jj_3R_75() {
    2732     if (jj_scan_token(WITHIN_CODE)) return true;
    2733     return false;
    2734   }
    2735
    2736   static final private boolean jj_3_9() {
    2737     if (jj_3R_33()) return true;
    2738     return false;
    2739   }
    2740
    2741   static final private boolean jj_3R_80() {
    2742     if (jj_scan_token(WITHIN)) return true;
    2743     return false;
    2744   }
    2745
    2746   static final private boolean jj_3R_81() {
    2747     if (jj_scan_token(HANDLER)) return true;
    2748     return false;
    2749   }
    2750
    2751   static final private boolean jj_3_8() {
    2752     if (jj_3R_32()) return true;
    2753     return false;
    2754   }
    2755
    2756   static final private boolean jj_3R_78() {
    2757     if (jj_scan_token(GET)) return true;
    2758     return false;
    2759   }
    2760
    2761   static final private boolean jj_3R_84() {
    2762     if (jj_scan_token(THIS)) return true;
    2763     return false;
    2764   }
    2765
    2766   static final private boolean jj_3R_39() {
    2767     if (jj_scan_token(FIELD_NOT)) return true;
    2768     return false;
    2769   }
    2770
    2771   static final private boolean jj_3R_32() {
    2772     Token xsp;
    2773     while (true) {
    2774       xsp = jj_scanpos;
    2775       if (jj_3R_39()) { jj_scanpos = xsp; break; }
    2776     }
    2777     if (jj_scan_token(FIELD_ANNOTATION)) return true;
    2778     return false;
    2779   }
    2780
    2781   static final private boolean jj_3_7() {
    2782     if (jj_3R_32()) return true;
    2783     return false;
    2784   }
    2785
    2786   static final private boolean jj_3R_77() {
    2787     if (jj_scan_token(SET)) return true;
    2788     return false;
    2789   }
    2790
    2791   static final private boolean jj_3_6() {
    2792     if (jj_3R_31()) return true;
    2793     return false;
    2794   }
    2795
    2796   static final private boolean jj_3R_83() {
    2797     if (jj_scan_token(TARGET)) return true;
    2798     return false;
    2799   }
    2800
    2801   static final private boolean jj_3R_36() {
    2802     if (jj_scan_token(METHOD_NOT)) return true;
    2803     return false;
    2804   }
    2805
    2806   static final private boolean jj_3R_30() {
    2807     Token xsp;
    2808     while (true) {
    2809       xsp = jj_scanpos;
    2810       if (jj_3R_36()) { jj_scanpos = xsp; break; }
    2811     }
    2812     if (jj_scan_token(METHOD_ANNOTATION)) return true;
    2813     return false;
    2814   }
    2815
    2816   static final private boolean jj_3R_54() {
    2817     if (jj_scan_token(METHOD_SYNCHRONIZED)) return true;
    2818     return false;
    2819   }
    2820
    2821   static final private boolean jj_3R_53() {
    2822     if (jj_scan_token(METHOD_PRIVATE)) return true;
    2823     return false;
    2824   }
    2825
    2826   static final private boolean jj_3_5() {
    2827     if (jj_3R_30()) return true;
    2828     return false;
    2829   }
    2830
    2831   static final private boolean jj_3R_73() {
    2832     if (jj_scan_token(CALL)) return true;
    2833     return false;
    2834   }
    2835
    2836   static final private boolean jj_3_17() {
    2837     if (jj_3R_32()) return true;
    2838     return false;
    2839   }
    2840
    2841   static final private boolean jj_3R_52() {
    2842     if (jj_scan_token(METHOD_PROTECTED)) return true;
    2843     return false;
    2844   }
    2845
    2846   static final private boolean jj_3R_79() {
    2847     if (jj_scan_token(HAS_FIELD)) return true;
    2848     return false;
    2849   }
    2850
    2851   static final private boolean jj_3_4() {
    2852     if (jj_3R_31()) return true;
    2853     return false;
    2854   }
    2855
    2856   static final private boolean jj_3_16() {
    2857     if (jj_3R_31()) return true;
    2858     return false;
    2859   }
    2860
    2861   static final private boolean jj_3R_51() {
    2862     if (jj_scan_token(METHOD_PUBLIC)) return true;
    2863     return false;
    2864   }
    2865
    2866   static final private boolean jj_3R_40() {
    2867     if (jj_scan_token(CLASS_NOT)) return true;
    2868     return false;
    2869   }
    2870
    2871   static final private boolean jj_3R_33() {
    2872     Token xsp;
    2873     while (true) {
    2874       xsp = jj_scanpos;
    2875       if (jj_3R_40()) { jj_scanpos = xsp; break; }
    2876     }
    2877     if (jj_scan_token(CLASS_ATTRIBUTE)) return true;
    2878     return false;
    2879   }
    2880
    2881   static final private boolean jj_3R_50() {
    2882     if (jj_scan_token(METHOD_NOT)) return true;
    2883     return false;
    2884   }
    2885
    2886   static final private boolean jj_3R_45() {
    2887     Token xsp;
    2888     while (true) {
    2889       xsp = jj_scanpos;
    2890       if (jj_3R_50()) { jj_scanpos = xsp; break; }
    2891     }
    2892     xsp = jj_scanpos;
    2893     if (jj_3R_51()) {
    2894     jj_scanpos = xsp;
    2895     if (jj_3R_52()) {
    2896     jj_scanpos = xsp;
    2897     if (jj_3R_53()) {
    2898     jj_scanpos = xsp;
    2899     if (jj_3R_54()) return true;
    2900     }
    2901     }
    2902     }
    2903     return false;
    2904   }
    2905
    2906   static private boolean jj_initialized_once = false;
    2907   static public ExpressionParserTokenManager token_source;
    2908   static SimpleCharStream jj_input_stream;
    2909   static public Token token, jj_nt;
    2910   static private int jj_ntk;
    2911   static private Token jj_scanpos, jj_lastpos;
    2912   static private int jj_la;
    2913   static public boolean lookingAhead = false;
    2914   static private boolean jj_semLA;
    2915   static private int jj_gen;
    2916   static final private int[] jj_la1 = new int[50];
    2917   static private int[] jj_la1_0;
    2918   static private int[] jj_la1_1;
    2919   static private int[] jj_la1_2;
    2920   static {
    2921       jj_la1_0();
    2922       jj_la1_1();
    2923       jj_la1_2();
    2924    }
    2925    private static void jj_la1_0() {
    2926       jj_la1_0 = new int[] {0x1efffc00,0x1efff800,0x18000000,0x88,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe0000080,0x0,0x0,0x0,0x0,0x0,0x0,0xe0000080,0x200000,0x0,0x0,0x0,0x0,0xe0000000,0x80,0x0,0x0,0x0,0x0,0x0,0x8,0x80,0x80,0x80,0x80,0x0,0x0,0x0,0x0,0xe0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
    2927    }
    2928    private static void jj_la1_1() {
    2929       jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0xcbfc00,0xcbfc00,0x4cbfc00,0xcbfc00,0xcbfc00,0x4cbfc00,0xf0000000,0xf0000000,0x2f,0xcbfc00,0xcbfc00,0x4cbfc00,0x4dffc00,0x48fc00,0x8fc00,0x2f,0x0,0xcbfc00,0xcbfc00,0x4cbfc00,0xf0000000,0xf,0x20,0xbfc00,0xc00000,0xa1c00,0xf0000000,0x0,0x0,0xc00000,0xc00000,0x0,0x0,0x8,0x80000,0x0,0x8,0x7,0x80000,0xfc00,0x80000,0x3fc00,0x80000,0x21c00,0x0,0xf0000000,};
    2930    }
    2931    private static void jj_la1_2() {
    2932       jj_la1_2 = new int[] {0x400000,0x0,0x0,0x2c0000,0x0,0x0,0x800000,0x0,0x0,0x800000,0xcf,0xcf,0x0,0x0,0x0,0x800000,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0xcf,0x0,0x0,0x0,0x0,0x0,0xf,0xc0,0x0,0x0,0x0,0xc0000,0xc0000,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x7,};
    2933    }
    2934   static final private JJCalls[] jj_2_rtns = new JJCalls[18];
    2935   static private boolean jj_rescan = false;
    2936   static private int jj_gc = 0;
    2937
    2938   public ExpressionParser(java.io.InputStream stream) {
    2939     if (jj_initialized_once) {
    2940       System.out.println("ERROR: Second call to constructor of static parser.  You must");
    2941       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
    2942       System.out.println("       during parser generation.");
    2943       throw new Error();
    2944     }
    2945     jj_initialized_once = true;
    2946     jj_input_stream = new SimpleCharStream(stream, 1, 1);
    2947     token_source = new ExpressionParserTokenManager(jj_input_stream);
    2948     token = new Token();
    2949     jj_ntk = -1;
    2950     jj_gen = 0;
    2951     for (int i = 0; i < 50; i++) jj_la1[i] = -1;
    2952     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    2953   }
    2954
    2955   static public void ReInit(java.io.InputStream stream) {
    2956     jj_input_stream.ReInit(stream, 1, 1);
    2957     token_source.ReInit(jj_input_stream);
    2958     token = new Token();
    2959     jj_ntk = -1;
    2960     jjtree.reset();
    2961     jj_gen = 0;
    2962     for (int i = 0; i < 50; i++) jj_la1[i] = -1;
    2963     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    2964   }
    2965
    2966   public ExpressionParser(java.io.Reader stream) {
    2967     if (jj_initialized_once) {
    2968       System.out.println("ERROR: Second call to constructor of static parser.  You must");
    2969       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
    2970       System.out.println("       during parser generation.");
    2971       throw new Error();
    2972     }
    2973     jj_initialized_once = true;
    2974     jj_input_stream = new SimpleCharStream(stream, 1, 1);
    2975     token_source = new ExpressionParserTokenManager(jj_input_stream);
    2976     token = new Token();
    2977     jj_ntk = -1;
    2978     jj_gen = 0;
    2979     for (int i = 0; i < 50; i++) jj_la1[i] = -1;
    2980     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    2981   }
    2982
    2983   static public void ReInit(java.io.Reader stream) {
    2984     jj_input_stream.ReInit(stream, 1, 1);
    2985     token_source.ReInit(jj_input_stream);
    2986     token = new Token();
    2987     jj_ntk = -1;
    2988     jjtree.reset();
    2989     jj_gen = 0;
    2990     for (int i = 0; i < 50; i++) jj_la1[i] = -1;
    2991     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    2992   }
    2993
    2994   public ExpressionParser(ExpressionParserTokenManager tm) {
    2995     if (jj_initialized_once) {
    2996       System.out.println("ERROR: Second call to constructor of static parser.  You must");
    2997       System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
    2998       System.out.println("       during parser generation.");
    2999       throw new Error();
    3000     }
    3001     jj_initialized_once = true;
    3002     token_source = tm;
    3003     token = new Token();
    3004     jj_ntk = -1;
    3005     jj_gen = 0;
    3006     for (int i = 0; i < 50; i++) jj_la1[i] = -1;
    3007     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3008   }
    3009
    3010   public void ReInit(ExpressionParserTokenManager tm) {
    3011     token_source = tm;
    3012     token = new Token();
    3013     jj_ntk = -1;
    3014     jjtree.reset();
    3015     jj_gen = 0;
    3016     for (int i = 0; i < 50; i++) jj_la1[i] = -1;
    3017     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3018   }
    3019
    3020   static final private Token jj_consume_token(int kind) throws ParseException {
    3021     Token oldToken;
    3022     if ((oldToken = token).next != null) token = token.next;
    3023     else token = token.next = token_source.getNextToken();
    3024     jj_ntk = -1;
    3025     if (token.kind == kind) {
    3026       jj_gen++;
    3027       if (++jj_gc > 100) {
    3028         jj_gc = 0;
    3029         for (int i = 0; i < jj_2_rtns.length; i++) {
    3030           JJCalls c = jj_2_rtns[i];
    3031           while (c != null) {
    3032             if (c.gen < jj_gen) c.first = null;
    3033             c = c.next;
    3034           }
    3035         }
    3036       }
    3037       return token;
    3038     }
    3039     token = oldToken;
    3040     jj_kind = kind;
    3041     throw generateParseException();
    3042   }
    3043
    3044   static private final class LookaheadSuccess extends java.lang.Error { }
    3045   static final private LookaheadSuccess jj_ls = new LookaheadSuccess();
    3046   static final private boolean jj_scan_token(int kind) {
    3047     if (jj_scanpos == jj_lastpos) {
    3048       jj_la--;
    3049       if (jj_scanpos.next == null) {
    3050         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
    3051       } else {
    3052         jj_lastpos = jj_scanpos = jj_scanpos.next;
    3053       }
    3054     } else {
    3055       jj_scanpos = jj_scanpos.next;
    3056     }
    3057     if (jj_rescan) {
    3058       int i = 0; Token tok = token;
    3059       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
    3060       if (tok != null) jj_add_error_token(kind, i);
    3061     }
    3062     if (jj_scanpos.kind != kind) return true;
    3063     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    3064     return false;
    3065   }
    3066
    3067   static final public Token getNextToken() {
    3068     if (token.next != null) token = token.next;
    3069     else token = token.next = token_source.getNextToken();
    3070     jj_ntk = -1;
    3071     jj_gen++;
    3072     return token;
    3073   }
    3074
    3075   static final public Token getToken(int index) {
    3076     Token t = lookingAhead ? jj_scanpos : token;
    3077     for (int i = 0; i < index; i++) {
    3078       if (t.next != null) t = t.next;
    3079       else t = t.next = token_source.getNextToken();
    3080     }
    3081     return t;
    3082   }
    3083
    3084   static final private int jj_ntk() {
    3085     if ((jj_nt=token.next) == null)
    3086       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    3087     else
    3088       return (jj_ntk = jj_nt.kind);
    3089   }
    3090
    3091   static private java.util.Vector jj_expentries = new java.util.Vector();
    3092   static private int[] jj_expentry;
    3093   static private int jj_kind = -1;
    3094   static private int[] jj_lasttokens = new int[100];
    3095   static private int jj_endpos;
    3096
    3097   static private void jj_add_error_token(int kind, int pos) {
    3098     if (pos >= 100) return;
    3099     if (pos == jj_endpos + 1) {
    3100       jj_lasttokens[jj_endpos++] = kind;
    3101     } else if (jj_endpos != 0) {
    3102       jj_expentry = new int[jj_endpos];
    3103       for (int i = 0; i < jj_endpos; i++) {
    3104         jj_expentry[i] = jj_lasttokens[i];
    3105       }
    3106       boolean exists = false;
    3107       for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
    3108         int[] oldentry = (int[])(e.nextElement());
    3109         if (oldentry.length == jj_expentry.length) {
    3110           exists = true;
    3111           for (int i = 0; i < jj_expentry.length; i++) {
    3112             if (oldentry[i] != jj_expentry[i]) {
    3113               exists = false;
    3114               break;
    3115             }
    3116           }
    3117           if (exists) break;
    3118         }
    3119       }
    3120       if (!exists) jj_expentries.addElement(jj_expentry);
    3121       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    3122     }
    3123   }
    3124
    3125   static public ParseException generateParseException() {
    3126     jj_expentries.removeAllElements();
    3127     boolean[] la1tokens = new boolean[88];
    3128     for (int i = 0; i < 88; i++) {
    3129       la1tokens[i] = false;
    3130     }
    3131     if (jj_kind >= 0) {
    3132       la1tokens[jj_kind] = true;
    3133       jj_kind = -1;
    3134     }
    3135     for (int i = 0; i < 50; i++) {
    3136       if (jj_la1[i] == jj_gen) {
    3137         for (int j = 0; j < 32; j++) {
    3138           if ((jj_la1_0[i] & (1<<j)) != 0) {
    3139             la1tokens[j] = true;
    3140           }
    3141           if ((jj_la1_1[i] & (1<<j)) != 0) {
    3142             la1tokens[32+j] = true;
    3143           }
    3144           if ((jj_la1_2[i] & (1<<j)) != 0) {
    3145             la1tokens[64+j] = true;
    3146           }
    3147         }
    3148       }
    3149     }
    3150     for (int i = 0; i < 88; i++) {
    3151       if (la1tokens[i]) {
    3152         jj_expentry = new int[1];
    3153         jj_expentry[0] = i;
    3154         jj_expentries.addElement(jj_expentry);
    3155       }
    3156     }
    3157     jj_endpos = 0;
    3158     jj_rescan_token();
    3159     jj_add_error_token(0, 0);
    3160     int[][] exptokseq = new int[jj_expentries.size()][];
    3161     for (int i = 0; i < jj_expentries.size(); i++) {
    3162       exptokseq[i] = (int[])jj_expentries.elementAt(i);
    3163     }
    3164     return new ParseException(token, exptokseq, tokenImage);
    3165   }
    3166
    3167   static final public void enable_tracing() {
    3168   }
    3169
    3170   static final public void disable_tracing() {
    3171   }
    3172
    3173   static final private void jj_rescan_token() {
    3174     jj_rescan = true;
    3175     for (int i = 0; i < 18; i++) {
    3176       JJCalls p = jj_2_rtns[i];
    3177       do {
    3178         if (p.gen > jj_gen) {
    3179           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
    3180           switch (i) {
    3181             case 0: jj_3_1(); break;
    3182             case 1: jj_3_2(); break;
    3183             case 2: jj_3_3(); break;
    3184             case 3: jj_3_4(); break;
    3185             case 4: jj_3_5(); break;
    3186             case 5: jj_3_6(); break;
    3187             case 6: jj_3_7(); break;
    3188             case 7: jj_3_8(); break;
    3189             case 8: jj_3_9(); break;
    3190             case 9: jj_3_10(); break;
    3191             case 10: jj_3_11(); break;
    3192             case 11: jj_3_12(); break;
    3193             case 12: jj_3_13(); break;
    3194             case 13: jj_3_14(); break;
    3195             case 14: jj_3_15(); break;
    3196             case 15: jj_3_16(); break;
    3197             case 16: jj_3_17(); break;
    3198             case 17: jj_3_18(); break;
    3199           }
    3200         }
    3201         p = p.next;
    3202       } while (p != null);
    3203     }
    3204     jj_rescan = false;
    3205   }
    3206
    3207   static final private void jj_save(int index, int xla) {
    3208     JJCalls p = jj_2_rtns[index];
    3209     while (p.gen > jj_gen) {
    3210       if (p.next == null) { p = p.next = new JJCalls(); break; }
    3211       p = p.next;
    3212     }
    3213     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
    3214   }
    3215
    3216   static final class JJCalls {
    3217     int gen;
    3218     Token first;
    3219     int arg;
    3220     JJCalls next;
    3221   }
    3222
    3223 }