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