PointcutExpressionParser


1   /* Generated By:JJTree&JavaCC: Do not edit this line. PointcutExpressionParser.java */
2   package org.jboss.aop.pointcut.ast;
3   
4   import java.lang.reflect.Modifier  ;
5   
6   public class PointcutExpressionParser/*@bgen(jjtree)*/implements PointcutExpressionParserTreeConstants, PointcutExpressionParserConstants {/*@bgen(jjtree)*/
7     protected JJTPointcutExpressionParserState jjtree = new JJTPointcutExpressionParserState();public static void main(String   args[]) {
8       System.out.println("Reading from standard input...");
9       PointcutExpressionParser t = new PointcutExpressionParser(System.in);
10      try {
11        ASTStart n = t.Start();
12        //PointcutExpressionParserVisitor v = new PointcutExpressionDumpVisitor();
13        //n.jjtAccept(v, null);
14      } catch (Exception   e) {
15        System.out.println("Oops.");
16        System.out.println(e.getMessage());
17        e.printStackTrace();
18      }
19    }
20  
21    final public ASTStart Start() throws ParseException {
22                             /*@bgen(jjtree) Start */
23    ASTStart jjtn000 = new ASTStart(JJTSTART);
24    boolean jjtc000 = true;
25    jjtree.openNodeScope(jjtn000);
26      try {
27        Expression();
28        jj_consume_token(0);
29      jjtree.closeNodeScope(jjtn000, true);
30      jjtc000 = false;
31      {if (true) return jjtn000;}
32      } catch (Throwable   jjte000) {
33      if (jjtc000) {
34        jjtree.clearNodeScope(jjtn000);
35        jjtc000 = false;
36      } else {
37        jjtree.popNode();
38      }
39      if (jjte000 instanceof RuntimeException  ) {
40        {if (true) throw (RuntimeException  )jjte000;}
41      }
42      if (jjte000 instanceof ParseException) {
43        {if (true) throw (ParseException)jjte000;}
44      }
45      {if (true) throw (Error  )jjte000;}
46      } finally {
47      if (jjtc000) {
48        jjtree.closeNodeScope(jjtn000, true);
49      }
50      }
51      throw new Error  ("Missing return statement in function");
52    }
53  
54    final public ASTExecution execution() throws ParseException {
55                                             /*@bgen(jjtree) ExecutionOnly */
56    ASTExecutionOnly jjtn000 = new ASTExecutionOnly(JJTEXECUTIONONLY);
57    boolean jjtc000 = true;
58    jjtree.openNodeScope(jjtn000);
59      try {
60        Execution();
61        jj_consume_token(0);
62      jjtree.closeNodeScope(jjtn000, true);
63      jjtc000 = false;
64      {if (true) return (ASTExecution)jjtn000.jjtGetChild(0);}
65      } catch (Throwable   jjte000) {
66      if (jjtc000) {
67        jjtree.clearNodeScope(jjtn000);
68        jjtc000 = false;
69      } else {
70        jjtree.popNode();
71      }
72      if (jjte000 instanceof RuntimeException  ) {
73        {if (true) throw (RuntimeException  )jjte000;}
74      }
75      if (jjte000 instanceof ParseException) {
76        {if (true) throw (ParseException)jjte000;}
77      }
78      {if (true) throw (Error  )jjte000;}
79      } finally {
80      if (jjtc000) {
81        jjtree.closeNodeScope(jjtn000, true);
82      }
83      }
84      throw new Error  ("Missing return statement in function");
85    }
86  
87    final public void Expression() throws ParseException {
88      if (jj_2_1(234234234)) {
89        BooleanExpression();
90      } else {
91        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
92        case CALL:
93        case ALL:
94        case EXECUTION:
95        case CONSTRUCTION:
96        case HAS:
97        case HAS_FIELD:
98        case GET:
99        case SET:
100       case FIELD:
101       case WITHIN:
102       case WITHINCODE:
103       case POINTCUT:
104         Concrete();
105         break;
106       case NOT:
107         Not();
108         break;
109       default:
110         jj_la1[0] = jj_gen;
111         jj_consume_token(-1);
112         throw new ParseException();
113       }
114     }
115   }
116 
117   final public void BooleanExpression() throws ParseException {
118                                      /*@bgen(jjtree) Boolean */
119   ASTBoolean jjtn000 = new ASTBoolean(JJTBOOLEAN);
120   boolean jjtc000 = true;
121   jjtree.openNodeScope(jjtn000);
122     try {
123       if (jj_2_2(3)) {
124         SubExpression();
125       } else if (jj_2_3(3)) {
126         CompositeExpression();
127       } else {
128         jj_consume_token(-1);
129         throw new ParseException();
130       }
131     } catch (Throwable   jjte000) {
132      if (jjtc000) {
133        jjtree.clearNodeScope(jjtn000);
134        jjtc000 = false;
135      } else {
136        jjtree.popNode();
137      }
138      if (jjte000 instanceof RuntimeException  ) {
139        {if (true) throw (RuntimeException  )jjte000;}
140      }
141      if (jjte000 instanceof ParseException) {
142        {if (true) throw (ParseException)jjte000;}
143      }
144      {if (true) throw (Error  )jjte000;}
145     } finally {
146      if (jjtc000) {
147        jjtree.closeNodeScope(jjtn000, true);
148      }
149     }
150   }
151 
152   final public void CompositeExpression() throws ParseException {
153                                          /*@bgen(jjtree) Composite */
154   ASTComposite jjtn000 = new ASTComposite(JJTCOMPOSITE);
155   boolean jjtc000 = true;
156   jjtree.openNodeScope(jjtn000);
157     try {
158       jj_consume_token(86);
159       SubExpression();
160       jj_consume_token(87);
161     } catch (Throwable   jjte000) {
162      if (jjtc000) {
163        jjtree.clearNodeScope(jjtn000);
164        jjtc000 = false;
165      } else {
166        jjtree.popNode();
167      }
168      if (jjte000 instanceof RuntimeException  ) {
169        {if (true) throw (RuntimeException  )jjte000;}
170      }
171      if (jjte000 instanceof ParseException) {
172        {if (true) throw (ParseException)jjte000;}
173      }
174      {if (true) throw (Error  )jjte000;}
175     } finally {
176      if (jjtc000) {
177        jjtree.closeNodeScope(jjtn000, true);
178      }
179     }
180   }
181 
182   final public void Not() throws ParseException {
183                    /*@bgen(jjtree) Not */
184   ASTNot jjtn000 = new ASTNot(JJTNOT);
185   boolean jjtc000 = true;
186   jjtree.openNodeScope(jjtn000);
187     try {
188       jj_consume_token(NOT);
189       if (jj_2_4(3)) {
190         ConcreteExpression();
191       } else if (jj_2_5(3)) {
192         CompositeExpression();
193       } else {
194         jj_consume_token(-1);
195         throw new ParseException();
196       }
197     } catch (Throwable   jjte000) {
198      if (jjtc000) {
199        jjtree.clearNodeScope(jjtn000);
200        jjtc000 = false;
201      } else {
202        jjtree.popNode();
203      }
204      if (jjte000 instanceof RuntimeException  ) {
205        {if (true) throw (RuntimeException  )jjte000;}
206      }
207      if (jjte000 instanceof ParseException) {
208        {if (true) throw (ParseException)jjte000;}
209      }
210      {if (true) throw (Error  )jjte000;}
211     } finally {
212      if (jjtc000) {
213        jjtree.closeNodeScope(jjtn000, true);
214      }
215     }
216   }
217 
218   final public void SubExpression() throws ParseException {
219                              /*@bgen(jjtree) Sub */
220   ASTSub jjtn000 = new ASTSub(JJTSUB);
221   boolean jjtc000 = true;
222   jjtree.openNodeScope(jjtn000);
223     try {
224       if (jj_2_6(3)) {
225         Not();
226       } else if (jj_2_7(3)) {
227         ConcreteExpression();
228       } else if (jj_2_8(3)) {
229         CompositeExpression();
230       } else {
231         jj_consume_token(-1);
232         throw new ParseException();
233       }
234       label_1:
235       while (true) {
236         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
237         case AND:
238           And();
239           break;
240         case OR:
241           Or();
242           break;
243         default:
244           jj_la1[1] = jj_gen;
245           jj_consume_token(-1);
246           throw new ParseException();
247         }
248         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
249         case AND:
250         case OR:
251           ;
252           break;
253         default:
254           jj_la1[2] = jj_gen;
255           break label_1;
256         }
257       }
258     } catch (Throwable   jjte000) {
259     if (jjtc000) {
260       jjtree.clearNodeScope(jjtn000);
261       jjtc000 = false;
262     } else {
263       jjtree.popNode();
264     }
265     if (jjte000 instanceof RuntimeException  ) {
266       {if (true) throw (RuntimeException  )jjte000;}
267     }
268     if (jjte000 instanceof ParseException) {
269       {if (true) throw (ParseException)jjte000;}
270     }
271     {if (true) throw (Error  )jjte000;}
272     } finally {
273     if (jjtc000) {
274       jjtree.closeNodeScope(jjtn000, true);
275     }
276     }
277   }
278 
279   final public void And() throws ParseException {
280                    /*@bgen(jjtree) And */
281   ASTAnd jjtn000 = new ASTAnd(JJTAND);
282   boolean jjtc000 = true;
283   jjtree.openNodeScope(jjtn000);
284     try {
285       jj_consume_token(AND);
286       if (jj_2_9(3)) {
287         ConcreteExpression();
288       } else if (jj_2_10(3)) {
289         CompositeExpression();
290       } else if (jj_2_11(3)) {
291         Not();
292       } else {
293         jj_consume_token(-1);
294         throw new ParseException();
295       }
296     } catch (Throwable   jjte000) {
297     if (jjtc000) {
298       jjtree.clearNodeScope(jjtn000);
299       jjtc000 = false;
300     } else {
301       jjtree.popNode();
302     }
303     if (jjte000 instanceof RuntimeException  ) {
304       {if (true) throw (RuntimeException  )jjte000;}
305     }
306     if (jjte000 instanceof ParseException) {
307       {if (true) throw (ParseException)jjte000;}
308     }
309     {if (true) throw (Error  )jjte000;}
310     } finally {
311     if (jjtc000) {
312       jjtree.closeNodeScope(jjtn000, true);
313     }
314     }
315   }
316 
317   final public void Or() throws ParseException {
318                  /*@bgen(jjtree) Or */
319   ASTOr jjtn000 = new ASTOr(JJTOR);
320   boolean jjtc000 = true;
321   jjtree.openNodeScope(jjtn000);
322     try {
323       jj_consume_token(OR);
324       if (jj_2_12(3)) {
325         ConcreteExpression();
326       } else if (jj_2_13(3)) {
327         CompositeExpression();
328       } else if (jj_2_14(3)) {
329         Not();
330       } else {
331         jj_consume_token(-1);
332         throw new ParseException();
333       }
334     } catch (Throwable   jjte000) {
335     if (jjtc000) {
336       jjtree.clearNodeScope(jjtn000);
337       jjtc000 = false;
338     } else {
339       jjtree.popNode();
340     }
341     if (jjte000 instanceof RuntimeException  ) {
342       {if (true) throw (RuntimeException  )jjte000;}
343     }
344     if (jjte000 instanceof ParseException) {
345       {if (true) throw (ParseException)jjte000;}
346     }
347     {if (true) throw (Error  )jjte000;}
348     } finally {
349     if (jjtc000) {
350       jjtree.closeNodeScope(jjtn000, true);
351     }
352     }
353   }
354 
355   final public ASTCFlowExpression CFlowExpression() throws ParseException {
356                                                          /*@bgen(jjtree) CFlowExpression */
357   ASTCFlowExpression jjtn000 = new ASTCFlowExpression(JJTCFLOWEXPRESSION);
358   boolean jjtc000 = true;
359   jjtree.openNodeScope(jjtn000);
360     try {
361       if (jj_2_15(3)) {
362         CFlowBoolean();
363       } else if (jj_2_16(3)) {
364         CFlow();
365       } else if (jj_2_17(3)) {
366         NotCFlow();
367       } else {
368         jj_consume_token(-1);
369         throw new ParseException();
370       }
371       jj_consume_token(0);
372     jjtree.closeNodeScope(jjtn000, true);
373     jjtc000 = false;
374     {if (true) return jjtn000;}
375     } catch (Throwable   jjte000) {
376     if (jjtc000) {
377       jjtree.clearNodeScope(jjtn000);
378       jjtc000 = false;
379     } else {
380       jjtree.popNode();
381     }
382     if (jjte000 instanceof RuntimeException  ) {
383       {if (true) throw (RuntimeException  )jjte000;}
384     }
385     if (jjte000 instanceof ParseException) {
386       {if (true) throw (ParseException)jjte000;}
387     }
388     {if (true) throw (Error  )jjte000;}
389     } finally {
390     if (jjtc000) {
391       jjtree.closeNodeScope(jjtn000, true);
392     }
393     }
394     throw new Error  ("Missing return statement in function");
395   }
396 
397   final public void CFlowBoolean() throws ParseException {
398                                      /*@bgen(jjtree) CFlowBoolean */
399   ASTCFlowBoolean jjtn000 = new ASTCFlowBoolean(JJTCFLOWBOOLEAN);
400   boolean jjtc000 = true;
401   jjtree.openNodeScope(jjtn000);
402     try {
403       CompositeCFlow();
404     } catch (Throwable   jjte000) {
405      if (jjtc000) {
406        jjtree.clearNodeScope(jjtn000);
407        jjtc000 = false;
408      } else {
409        jjtree.popNode();
410      }
411      if (jjte000 instanceof RuntimeException  ) {
412        {if (true) throw (RuntimeException  )jjte000;}
413      }
414      if (jjte000 instanceof ParseException) {
415        {if (true) throw (ParseException)jjte000;}
416      }
417      {if (true) throw (Error  )jjte000;}
418     } finally {
419      if (jjtc000) {
420        jjtree.closeNodeScope(jjtn000, true);
421      }
422     }
423   }
424 
425   final public void NotCFlow() throws ParseException {
426                              /*@bgen(jjtree) NotCFlow */
427   ASTNotCFlow jjtn000 = new ASTNotCFlow(JJTNOTCFLOW);
428   boolean jjtc000 = true;
429   jjtree.openNodeScope(jjtn000);
430     try {
431       jj_consume_token(NOT);
432       if (jj_2_18(3)) {
433         CFlow();
434       } else if (jj_2_19(3)) {
435         CompositeCFlow();
436       } else {
437         jj_consume_token(-1);
438         throw new ParseException();
439       }
440     } catch (Throwable   jjte000) {
441      if (jjtc000) {
442        jjtree.clearNodeScope(jjtn000);
443        jjtc000 = false;
444      } else {
445        jjtree.popNode();
446      }
447      if (jjte000 instanceof RuntimeException  ) {
448        {if (true) throw (RuntimeException  )jjte000;}
449      }
450      if (jjte000 instanceof ParseException) {
451        {if (true) throw (ParseException)jjte000;}
452      }
453      {if (true) throw (Error  )jjte000;}
454     } finally {
455      if (jjtc000) {
456        jjtree.closeNodeScope(jjtn000, true);
457      }
458     }
459   }
460 
461   final public void CompositeCFlow() throws ParseException {
462                                          /*@bgen(jjtree) CompositeCFlow */
463   ASTCompositeCFlow jjtn000 = new ASTCompositeCFlow(JJTCOMPOSITECFLOW);
464   boolean jjtc000 = true;
465   jjtree.openNodeScope(jjtn000);
466     try {
467       jj_consume_token(86);
468       SubCFlow();
469       jj_consume_token(87);
470     } catch (Throwable   jjte000) {
471      if (jjtc000) {
472        jjtree.clearNodeScope(jjtn000);
473        jjtc000 = false;
474      } else {
475        jjtree.popNode();
476      }
477      if (jjte000 instanceof RuntimeException  ) {
478        {if (true) throw (RuntimeException  )jjte000;}
479      }
480      if (jjte000 instanceof ParseException) {
481        {if (true) throw (ParseException)jjte000;}
482      }
483      {if (true) throw (Error  )jjte000;}
484     } finally {
485      if (jjtc000) {
486        jjtree.closeNodeScope(jjtn000, true);
487      }
488     }
489   }
490 
491   final public void SubCFlow() throws ParseException {
492                              /*@bgen(jjtree) SubCFlow */
493   ASTSubCFlow jjtn000 = new ASTSubCFlow(JJTSUBCFLOW);
494   boolean jjtc000 = true;
495   jjtree.openNodeScope(jjtn000);
496     try {
497       if (jj_2_20(3)) {
498         NotCFlow();
499       } else if (jj_2_21(3)) {
500         CFlow();
501       } else {
502         jj_consume_token(-1);
503         throw new ParseException();
504       }
505       label_2:
506       while (true) {
507         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
508         case AND:
509           AndCFlow();
510           break;
511         case OR:
512           OrCFlow();
513           break;
514         default:
515           jj_la1[3] = jj_gen;
516           jj_consume_token(-1);
517           throw new ParseException();
518         }
519         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
520         case AND:
521         case OR:
522           ;
523           break;
524         default:
525           jj_la1[4] = jj_gen;
526           break label_2;
527         }
528       }
529     } catch (Throwable   jjte000) {
530      if (jjtc000) {
531        jjtree.clearNodeScope(jjtn000);
532        jjtc000 = false;
533      } else {
534        jjtree.popNode();
535      }
536      if (jjte000 instanceof RuntimeException  ) {
537        {if (true) throw (RuntimeException  )jjte000;}
538      }
539      if (jjte000 instanceof ParseException) {
540        {if (true) throw (ParseException)jjte000;}
541      }
542      {if (true) throw (Error  )jjte000;}
543     } finally {
544      if (jjtc000) {
545        jjtree.closeNodeScope(jjtn000, true);
546      }
547     }
548   }
549 
550   final public void AndCFlow() throws ParseException {
551                              /*@bgen(jjtree) AndCFlow */
552   ASTAndCFlow jjtn000 = new ASTAndCFlow(JJTANDCFLOW);
553   boolean jjtc000 = true;
554   jjtree.openNodeScope(jjtn000);
555     try {
556       jj_consume_token(AND);
557       if (jj_2_22(3)) {
558         CFlow();
559       } else if (jj_2_23(3)) {
560         CompositeCFlow();
561       } else {
562         jj_consume_token(-1);
563         throw new ParseException();
564       }
565     } catch (Throwable   jjte000) {
566     if (jjtc000) {
567       jjtree.clearNodeScope(jjtn000);
568       jjtc000 = false;
569     } else {
570       jjtree.popNode();
571     }
572     if (jjte000 instanceof RuntimeException  ) {
573       {if (true) throw (RuntimeException  )jjte000;}
574     }
575     if (jjte000 instanceof ParseException) {
576       {if (true) throw (ParseException)jjte000;}
577     }
578     {if (true) throw (Error  )jjte000;}
579     } finally {
580     if (jjtc000) {
581       jjtree.closeNodeScope(jjtn000, true);
582     }
583     }
584   }
585 
586   final public void OrCFlow() throws ParseException {
587                            /*@bgen(jjtree) OrCFlow */
588   ASTOrCFlow jjtn000 = new ASTOrCFlow(JJTORCFLOW);
589   boolean jjtc000 = true;
590   jjtree.openNodeScope(jjtn000);
591     try {
592       jj_consume_token(OR);
593       if (jj_2_24(3)) {
594         CFlow();
595       } else if (jj_2_25(3)) {
596         CompositeCFlow();
597       } else {
598         jj_consume_token(-1);
599         throw new ParseException();
600       }
601     } catch (Throwable   jjte000) {
602     if (jjtc000) {
603       jjtree.clearNodeScope(jjtn000);
604       jjtc000 = false;
605     } else {
606       jjtree.popNode();
607     }
608     if (jjte000 instanceof RuntimeException  ) {
609       {if (true) throw (RuntimeException  )jjte000;}
610     }
611     if (jjte000 instanceof ParseException) {
612       {if (true) throw (ParseException)jjte000;}
613     }
614     {if (true) throw (Error  )jjte000;}
615     } finally {
616     if (jjtc000) {
617       jjtree.closeNodeScope(jjtn000, true);
618     }
619     }
620   }
621 
622   final public void ConcreteExpression() throws ParseException {
623     Concrete();
624   }
625 
626   final public void Concrete() throws ParseException {
627     if (jj_2_26(4)) {
628       Call();
629     } else if (jj_2_27(4)) {
630       Within();
631     } else if (jj_2_28(4)) {
632       Withincode();
633     } else if (jj_2_29(4)) {
634       Execution();
635     } else if (jj_2_30(4)) {
636       Construction();
637     } else if (jj_2_31(4)) {
638       Set();
639     } else if (jj_2_32(4)) {
640       Get();
641     } else if (jj_2_33(4)) {
642       FieldExecution();
643     } else if (jj_2_34(4)) {
644       Pointcut();
645     } else if (jj_2_35(4)) {
646       All();
647     } else if (jj_2_36(4)) {
648       Has();
649     } else if (jj_2_37(4)) {
650       HasField();
651     } else {
652       jj_consume_token(-1);
653       throw new ParseException();
654     }
655   }
656 
657   final public void Pointcut() throws ParseException {
658  /*@bgen(jjtree) Pointcut */
659   ASTPointcut jjtn000 = new ASTPointcut(JJTPOINTCUT);
660   boolean jjtc000 = true;
661   jjtree.openNodeScope(jjtn000);Token pointcut;
662     try {
663       pointcut = jj_consume_token(POINTCUT);
664      jjtree.closeNodeScope(jjtn000, true);
665      jjtc000 = false;
666       jjtn000.setPointcutName(pointcut.image);
667     } finally {
668      if (jjtc000) {
669        jjtree.closeNodeScope(jjtn000, true);
670      }
671     }
672   }
673 
674   final public void CFlow() throws ParseException {
675  /*@bgen(jjtree) CFlow */
676   ASTCFlow jjtn000 = new ASTCFlow(JJTCFLOW);
677   boolean jjtc000 = true;
678   jjtree.openNodeScope(jjtn000);Token pointcut;
679     try {
680       pointcut = jj_consume_token(POINTCUT);
681      jjtree.closeNodeScope(jjtn000, true);
682      jjtc000 = false;
683       jjtn000.setPointcutName(pointcut.image);
684     } finally {
685      if (jjtc000) {
686        jjtree.closeNodeScope(jjtn000, true);
687      }
688     }
689   }
690 
691   final public void All() throws ParseException {
692  /*@bgen(jjtree) All */
693   ASTAll jjtn000 = new ASTAll(JJTALL);
694   boolean jjtc000 = true;
695   jjtree.openNodeScope(jjtn000);Token pointcut;
696     try {
697       jj_consume_token(ALL);
698       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
699       case FIELD_CLASS:
700         pointcut = jj_consume_token(FIELD_CLASS);
701         break;
702       case FIELD_IDENTIFIER:
703         pointcut = jj_consume_token(FIELD_IDENTIFIER);
704         break;
705       case FIELD_ANNOTATION:
706         pointcut = jj_consume_token(FIELD_ANNOTATION);
707         break;
708       case FIELD_INSTANCEOF:
709         pointcut = jj_consume_token(FIELD_INSTANCEOF);
710         break;
711       case FIELD_TYPEDEF:
712         pointcut = jj_consume_token(FIELD_TYPEDEF);
713         break;
714       default:
715         jj_la1[5] = jj_gen;
716         jj_consume_token(-1);
717         throw new ParseException();
718       }
719       jjtn000.setClassExpression(pointcut.image);
720       jj_consume_token(FIELD_CLOSE);
721     } finally {
722      if (jjtc000) {
723        jjtree.closeNodeScope(jjtn000, true);
724      }
725     }
726   }
727 
728   final public void Call() throws ParseException {
729                      /*@bgen(jjtree) Call */
730   ASTCall jjtn000 = new ASTCall(JJTCALL);
731   boolean jjtc000 = true;
732   jjtree.openNodeScope(jjtn000);
733     try {
734       jj_consume_token(CALL);
735       if (jj_2_38(4)) {
736         Method();
737       } else if (jj_2_39(4)) {
738         Constructor();
739       } else {
740         jj_consume_token(-1);
741         throw new ParseException();
742       }
743       jj_consume_token(BEHAVIOR_CLOSE);
744     } catch (Throwable   jjte000) {
745      if (jjtc000) {
746        jjtree.clearNodeScope(jjtn000);
747        jjtc000 = false;
748      } else {
749        jjtree.popNode();
750      }
751      if (jjte000 instanceof RuntimeException  ) {
752        {if (true) throw (RuntimeException  )jjte000;}
753      }
754      if (jjte000 instanceof ParseException) {
755        {if (true) throw (ParseException)jjte000;}
756      }
757      {if (true) throw (Error  )jjte000;}
758     } finally {
759      if (jjtc000) {
760        jjtree.closeNodeScope(jjtn000, true);
761      }
762     }
763   }
764 
765   final public void Within() throws ParseException {
766  /*@bgen(jjtree) Within */
767    ASTWithin jjtn000 = new ASTWithin(JJTWITHIN);
768    boolean jjtc000 = true;
769    jjtree.openNodeScope(jjtn000);Token clazz;
770     try {
771       jj_consume_token(WITHIN);
772       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
773       case FIELD_CLASS:
774         clazz = jj_consume_token(FIELD_CLASS);
775         break;
776       case FIELD_IDENTIFIER:
777         clazz = jj_consume_token(FIELD_IDENTIFIER);
778         break;
779       case FIELD_ANNOTATION:
780         clazz = jj_consume_token(FIELD_ANNOTATION);
781         break;
782       case FIELD_INSTANCEOF:
783         clazz = jj_consume_token(FIELD_INSTANCEOF);
784         break;
785       case FIELD_TYPEDEF:
786         clazz = jj_consume_token(FIELD_TYPEDEF);
787         break;
788       default:
789         jj_la1[6] = jj_gen;
790         jj_consume_token(-1);
791         throw new ParseException();
792       }
793       jj_consume_token(FIELD_CLOSE);
794      jjtree.closeNodeScope(jjtn000, true);
795      jjtc000 = false;
796      jjtn000.setClassExpression(clazz.image);
797     } finally {
798     if (jjtc000) {
799       jjtree.closeNodeScope(jjtn000, true);
800     }
801     }
802   }
803 
804   final public void Withincode() throws ParseException {
805                                  /*@bgen(jjtree) Withincode */
806   ASTWithincode jjtn000 = new ASTWithincode(JJTWITHINCODE);
807   boolean jjtc000 = true;
808   jjtree.openNodeScope(jjtn000);
809     try {
810       jj_consume_token(WITHINCODE);
811       if (jj_2_40(3)) {
812         Method();
813       } else if (jj_2_41(3)) {
814         Constructor();
815       } else {
816         jj_consume_token(-1);
817         throw new ParseException();
818       }
819       jj_consume_token(BEHAVIOR_CLOSE);
820     } catch (Throwable   jjte000) {
821      if (jjtc000) {
822        jjtree.clearNodeScope(jjtn000);
823        jjtc000 = false;
824      } else {
825        jjtree.popNode();
826      }
827      if (jjte000 instanceof RuntimeException  ) {
828        {if (true) throw (