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 }