KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > codehaus > aspectwerkz > expression > ast > ExpressionParser


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 JavaDoc;
12 import java.io.Reader JavaDoc;
13 import java.io.StringReader JavaDoc;
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 JavaDoc expression) throws ParseException {
34         return parse(new StringReader JavaDoc(expression));
35     }
36
37     public ASTRoot parse(Reader JavaDoc 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 JavaDoc jjte000) {
59       if (jjtc000) {
60         jjtree.clearNodeScope(jjtn000);
61         jjtc000 = false;
62       } else {
63         jjtree.popNode();
64       }
65       if (jjte000 instanceof RuntimeException JavaDoc) {
66         {if (true) throw (RuntimeException JavaDoc)jjte000;}
67       }
68       if (jjte000 instanceof ParseException) {
69         {if (true) throw (ParseException)jjte000;}
70       }
71       {if (true) throw (Error JavaDoc)jjte000;}
72     } finally {
73       if (jjtc000) {
74         jjtree.closeNodeScope(jjtn000, true);
75       }
76     }
77     throw new Error JavaDoc("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 JavaDoc jjte000) {
91       if (jjtc000) {
92         jjtree.clearNodeScope(jjtn000);
93         jjtc000 = false;
94       } else {
95         jjtree.popNode();
96       }
97       if (jjte000 instanceof RuntimeException JavaDoc) {
98         {if (true) throw (RuntimeException JavaDoc)jjte000;}
99       }
100       if (jjte000 instanceof ParseException) {
101         {if (true) throw (ParseException)jjte000;}
102       }
103       {if (true) throw (Error JavaDoc)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 JavaDoc jjte001) {
133       if (jjtc001) {
134         jjtree.clearNodeScope(jjtn001);
135         jjtc001 = false;
136       } else {
137         jjtree.popNode();
138       }
139       if (jjte001 instanceof RuntimeException JavaDoc) {
140         {if (true) throw (RuntimeException JavaDoc)jjte001;}
141       }
142       if (jjte001 instanceof ParseException) {
143         {if (true) throw (ParseException)jjte001;}
144       }
145       {if (true) throw (Error JavaDoc)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 JavaDoc jjte001) {
173       if (jjtc001) {
174         jjtree.clearNodeScope(jjtn001);
175         jjtc001 = false;
176       } else {
177         jjtree.popNode();
178       }
179       if (jjte001 instanceof RuntimeException JavaDoc) {
180         {if (true) throw (RuntimeException JavaDoc)jjte001;}
181       }
182       if (jjte001 instanceof ParseException) {
183         {if (true) throw (ParseException)jjte001;}
184       }
185       {if (true) throw (Error JavaDoc)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 JavaDoc jjte001) {
243             if (jjtc001) {
244               jjtree.clearNodeScope(jjtn001);
245               jjtc001 = false;
246             } else {
247               jjtree.popNode();
248             }
249             if (jjte001 instanceof RuntimeException JavaDoc) {
250               {if (true) throw (RuntimeException JavaDoc)jjte001;}
251             }
252             if (jjte001 instanceof ParseException) {
253               {if (true) throw (ParseException)jjte001;}
254             }
255             {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
362       if (jjtc000) {
363         jjtree.clearNodeScope(jjtn000);
364         jjtc000 = false;
365       } else {
366         jjtree.popNode();
367       }
368       if (jjte000 instanceof RuntimeException JavaDoc) {
369         {if (true) throw (RuntimeException JavaDoc)jjte000;}
370       }
371       if (jjte000 instanceof ParseException) {
372         {if (true) throw (ParseException)jjte000;}
373       }
374       {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
465       if (jjtc000) {
466         jjtree.clearNodeScope(jjtn000);
467         jjtc000 = false;
468       } else {
469         jjtree.popNode();
470       }
471       if (jjte000 instanceof RuntimeException JavaDoc) {
472         {if (true) throw (RuntimeException JavaDoc)jjte000;}
473       }
474       if (jjte000 instanceof ParseException) {
475         {if (true) throw (ParseException)jjte000;}
476       }
477       {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
568       if (jjtc000) {
569         jjtree.clearNodeScope(jjtn000);
570         jjtc000 = false;
571       } else {
572         jjtree.popNode();
573       }
574       if (jjte000 instanceof RuntimeException JavaDoc) {
575         {if (true) throw (RuntimeException JavaDoc)jjte000;}
576       }
577       if (jjte000 instanceof ParseException) {
578         {if (true) throw (ParseException)jjte000;}
579       }
580       {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
626       if (jjtc000) {
627         jjtree.clearNodeScope(jjtn000);
628         jjtc000 = false;
629       } else {
630         jjtree.popNode();
631       }
632       if (jjte000 instanceof RuntimeException JavaDoc) {
633         {if (true) throw (RuntimeException JavaDoc)jjte000;}
634       }
635       if (jjte000 instanceof ParseException) {
636         {if (true) throw (ParseException)jjte000;}
637       }
638       {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
684       if (jjtc000) {
685         jjtree.clearNodeScope(jjtn000);
686         jjtc000 = false;
687       } else {
688         jjtree.popNode();
689       }
690       if (jjte000 instanceof RuntimeException JavaDoc) {
691         {if (true) throw (RuntimeException JavaDoc)jjte000;}
692       }
693       if (jjte000 instanceof ParseException) {
694         {if (true) throw (ParseException)jjte000;}
695       }
696       {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
717       if (jjtc000) {
718         jjtree.clearNodeScope(jjtn000);
719         jjtc000 = false;
720       } else {
721         jjtree.popNode();
722       }
723       if (jjte000 instanceof RuntimeException JavaDoc) {
724         {if (true) throw (RuntimeException JavaDoc)jjte000;}
725       }
726       if (jjte000 instanceof ParseException) {
727         {if (true) throw (ParseException)jjte000;}
728       }
729       {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
774       if (jjtc000) {
775         jjtree.clearNodeScope(jjtn000);
776         jjtc000 = false;
777       } else {
778         jjtree.popNode();
779       }
780       if (jjte000 instanceof RuntimeException JavaDoc) {
781         {if (true) throw (RuntimeException JavaDoc)jjte000;}
782       }
783       if (jjte000 instanceof ParseException) {
784         {if (true) throw (ParseException)jjte000;}
785       }
786       {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
905           if (jjtc000) {
906             jjtree.clearNodeScope(jjtn000);
907             jjtc000 = false;
908           } else {
909             jjtree.popNode();
910           }
911           if (jjte000 instanceof RuntimeException JavaDoc) {
912             {if (true) throw (RuntimeException JavaDoc)jjte000;}
913           }
914           if (jjte000 instanceof ParseException) {
915             {if (true) throw (ParseException)jjte000;}
916           }
917           {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
959                   if (jjtc000) {
960                     jjtree.clearNodeScope(jjtn000);
961                     jjtc000 = false;
962                   } else {
963                     jjtree.popNode();
964                   }
965                   if (jjte000 instanceof RuntimeException JavaDoc) {
966                     {if (true) throw (RuntimeException JavaDoc)jjte000;}
967                   }
968                   if (jjte000 instanceof ParseException) {
969                     {if (true) throw (ParseException)jjte000;}
970                   }
971                   {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
1008          if (jjtc000) {
1009            jjtree.clearNodeScope(jjtn000);
1010            jjtc000 = false;
1011          } else {
1012            jjtree.popNode();
1013          }
1014          if (jjte000 instanceof RuntimeException JavaDoc) {
1015            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1016          }
1017          if (jjte000 instanceof ParseException) {
1018            {if (true) throw (ParseException)jjte000;}
1019          }
1020          {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
1065      if (jjtc000) {
1066        jjtree.clearNodeScope(jjtn000);
1067        jjtc000 = false;
1068      } else {
1069        jjtree.popNode();
1070      }
1071      if (jjte000 instanceof RuntimeException JavaDoc) {
1072        {if (true) throw (RuntimeException JavaDoc)jjte000;}
1073      }
1074      if (jjte000 instanceof ParseException) {
1075        {if (true) throw (ParseException)jjte000;}
1076      }
1077      {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
1098     if (jjtc000) {
1099       jjtree.clearNodeScope(jjtn000);
1100       jjtc000 = false;
1101     } else {
1102       jjtree.popNode();
1103     }
1104     if (jjte000 instanceof RuntimeException JavaDoc) {
1105       {if (true) throw (RuntimeException JavaDoc)jjte000;}
1106     }
1107     if (jjte000 instanceof ParseException) {
1108       {if (true) throw (ParseException)jjte000;}
1109     }
1110     {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
1131     if (jjtc000) {
1132       jjtree.clearNodeScope(jjtn000);
1133       jjtc000 = false;
1134     } else {
1135       jjtree.popNode();
1136     }
1137     if (jjte000 instanceof RuntimeException JavaDoc) {
1138       {if (true) throw (RuntimeException JavaDoc)jjte000;}
1139     }
1140     if (jjte000 instanceof ParseException) {
1141       {if (true) throw (ParseException)jjte000;}
1142     }
1143     {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
1177      if (jjtc000) {
1178        jjtree.clearNodeScope(jjtn000);
1179        jjtc000 = false;
1180      } else {
1181        jjtree.popNode();
1182      }
1183      if (jjte000 instanceof RuntimeException JavaDoc) {
1184        {if (true) throw (RuntimeException JavaDoc)jjte000;}
1185      }
1186      if (jjte000 instanceof ParseException) {
1187        {if (true) throw (ParseException)jjte000;}
1188      }
1189      {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
1280          if (jjtc000) {
1281            jjtree.clearNodeScope(jjtn000);
1282            jjtc000 = false;
1283          } else {
1284            jjtree.popNode();
1285          }
1286          if (jjte000 instanceof RuntimeException JavaDoc) {
1287            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1288          }
1289          if (jjte000 instanceof ParseException) {
1290            {if (true) throw (ParseException)jjte000;}
1291          }
1292          {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
1338     if (jjtc000) {
1339       jjtree.clearNodeScope(jjtn000);
1340       jjtc000 = false;
1341     } else {
1342       jjtree.popNode();
1343     }
1344     if (jjte000 instanceof RuntimeException JavaDoc) {
1345       {if (true) throw (RuntimeException JavaDoc)jjte000;}
1346     }
1347     if (jjte000 instanceof ParseException) {
1348       {if (true) throw (ParseException)jjte000;}
1349     }
1350     {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
1443      if (jjtc000) {
1444        jjtree.clearNodeScope(jjtn000);
1445        jjtc000 = false;
1446      } else {
1447        jjtree.popNode();
1448      }
1449      if (jjte000 instanceof RuntimeException JavaDoc) {
1450        {if (true) throw (RuntimeException JavaDoc)jjte000;}
1451      }
1452      if (jjte000 instanceof ParseException) {
1453        {if (true) throw (ParseException)jjte000;}
1454      }
1455      {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
1513              if (jjtc000) {
1514                jjtree.clearNodeScope(jjtn000);
1515                jjtc000 = false;
1516              } else {
1517                jjtree.popNode();
1518              }
1519              if (jjte000 instanceof RuntimeException JavaDoc) {
1520                {if (true) throw (RuntimeException JavaDoc)jjte000;}
1521              }
1522              if (jjte000 instanceof ParseException) {
1523                {if (true) throw (ParseException)jjte000;}
1524              }
1525              {if (true) throw (Error JavaDoc)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 JavaDoc("constructor pattern must have 'new' as method name");}
1565        }
1566        jjtn000.setFullNamePattern(name.image);
1567      Parameters();
1568    } catch (Throwable JavaDoc jjte000) {
1569      if (jjtc000) {
1570        jjtree.clearNodeScope(jjtn000);
1571        jjtc000 = false;
1572      } else {
1573        jjtree.popNode();
1574      }
1575      if (jjte000 instanceof RuntimeException JavaDoc) {
1576        {if (true) throw (RuntimeException JavaDoc)jjte000;}
1577      }
1578      if (jjte000 instanceof ParseException) {
1579        {if (true) throw (ParseException)jjte000;}
1580      }
1581      {if (true) throw (Error JavaDoc)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 JavaDoc jjte000) {
1639      if (jjtc000) {
1640        jjtree.clearNodeScope(jjtn000);
1641        jjtc000 = false;
1642      } else {
1643        jjtree.popNode();
1644      }
1645      if (jjte000 instanceof RuntimeException JavaDoc) {
1646        {if (true) throw (RuntimeException JavaDoc)jjte000;}
1647      }
1648      if (jjte000 instanceof ParseException) {
1649        {if (true) throw (ParseException)jjte000;}
1650      }
1651      {if (true) throw (Error JavaDoc)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 JavaDoc 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 JavaDoc();
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 JavaDoc 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 JavaDoc 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 JavaDoc();
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 JavaDoc 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 JavaDoc();
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 JavaDoc { }
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 JavaDoc jj_expentries = new java.util.Vector JavaDoc();
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 JavaDoc 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}
3224
Popular Tags