KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > debugger > jpda > expr > JavaParser


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */

19
20 /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParser.java */
21 package org.netbeans.modules.debugger.jpda.expr;
22
23 class JavaParser/*@bgen(jjtree)*/implements JavaParserTreeConstants, JavaParserConstants {/*@bgen(jjtree)*/
24   protected JJTJavaParserState jjtree = new JJTJavaParserState();
25   public static final String JavaDoc LANGUAGE_JAVA_1_4 = "1.4.0";
26   public static final String JavaDoc LANGUAGE_JAVA_1_5 = "1.5.0";
27
28   private String JavaDoc target_jdk;
29   private boolean jdk1_5;
30   private boolean generics;
31
32   public void setTargetJDK(String JavaDoc target) {
33      target_jdk = target;
34      jdk1_5 = "1.5.0".compareTo(target_jdk) <= 0;
35      generics = "1.5.0".compareTo(target_jdk) <= 0;
36   }
37
38   private boolean expressionLookahead() {
39      Token tok = getToken(1);
40      if (tok.kind==COMMA) {
41         tok = getToken(2);
42         if (!(tok.kind==RPAREN || tok.kind==RBRACE)) {
43             return true;
44         }
45      }
46      return false;
47   }
48
49    private boolean castLookahead() {
50       int x = 0;
51       Token tok = getToken(++x);
52       if (tok.kind!=LPAREN) {
53          return false;
54       }
55       tok = getToken(++x);
56       if (tok.kind==IDENTIFIER) {
57          tok = getToken(++x);
58          while (true) {
59             if (tok.kind==LT) {
60                x = typeArguments(x);
61                if (x<0) {
62                   return false;
63                }
64                tok = getToken(x); // load next token
65
}
66             if (tok.kind==LBRACKET) {
67                while (tok.kind==LBRACKET) {
68                   tok = getToken(++x);
69                   if (tok.kind!=RBRACKET) {
70                      return false;
71                   }
72                   tok = getToken(++x);
73                }
74             }
75             if (tok.kind==RPAREN) {
76                tok = getToken(++x);
77                return castEnd(tok);
78             } else if (tok.kind!=DOT) {
79                return false;
80             }
81             tok = getToken(++x);
82             if (isPrimitiveType(tok)) {
83                tok = getToken(++x);
84                if (tok.kind==LBRACKET) {
85                   while (tok.kind==LBRACKET) {
86                      tok = getToken(++x);
87                      if (tok.kind!=RBRACKET) {
88                         return false;
89                      }
90                      tok = getToken(++x);
91                   }
92                }
93                return (tok.kind==RPAREN);
94             } else if (tok.kind==IDENTIFIER) {
95                tok = getToken(++x);
96             }
97
98          }
99       } else if (isPrimitiveType(tok)) {
100          tok = getToken(++x);
101          if (tok.kind==LBRACKET) {
102             while (tok.kind==LBRACKET) {
103                tok = getToken(++x);
104                if (tok.kind!=RBRACKET) {
105                   return false;
106                }
107                tok = getToken(++x);
108             }
109          }
110          return (tok.kind==RPAREN);
111       }
112       return false;
113    }
114
115
116    private boolean isPrimitiveType(Token tok) {
117       return tok.kind==BOOLEAN || tok.kind==CHAR || tok.kind==BYTE
118           || tok.kind==SHORT || tok.kind==INT || tok.kind==LONG
119           || tok.kind==FLOAT || tok.kind==DOUBLE;
120    }
121
122    private int typeArguments(int x) {
123       int level = 1;
124       while (true) {
125          Token tok = getToken(++x);
126          if (tok.kind==GT) {
127             --level;
128             if (level==0) {
129                return x+1;
130             } else if (level < 0) {
131                return -1; // this is probably a syntax error
132
}
133          } else if (tok.kind==RSIGNEDSHIFT) {
134             level -= 2;
135             if (level==0) {
136                return x+1;
137             } else if (level < 0) {
138                return -1; // this is probably a syntax error
139
}
140          } else if (tok.kind==RUNSIGNEDSHIFT) {
141             level -= 2;
142             if (level==0) {
143                return x+1;
144             } else if (level < 0) {
145                return -1; // this is probably a syntax error
146
}
147          } else if (tok.kind==LT) {
148             level++;
149          }
150
151          if (tok.kind==RPAREN) {
152             return -1;
153          } else if (tok.kind==DOT) {
154          } else if (tok.kind==HOOK || tok.kind==SUPER || tok.kind==EXTENDS || tok.kind==IDENTIFIER) {
155             // do nothing
156
}
157       }
158    }
159
160
161    private boolean castEnd(Token tok) {
162       return ( tok.kind==TILDE || tok.kind==BANG || tok.kind==LPAREN || tok.kind==IDENTIFIER
163               || tok.kind==THIS || tok.kind==SUPER || tok.kind==NEW
164               || tok.kind==INTEGER_LITERAL || tok.kind==FLOATING_POINT_LITERAL
165               || tok.kind==CHARACTER_LITERAL || tok.kind==STRING_LITERAL
166               || tok.kind==TRUE || tok.kind==FALSE || tok.kind==NULL );
167    }
168
169
170   public static void main(String JavaDoc args[]) {
171   }
172
173 /*****************************************
174  * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
175  *****************************************/

176   final public void ReferenceTypeList() throws ParseException {
177  /*@bgen(jjtree) ReferenceTypeList */
178     SimpleNode jjtn000 = new SimpleNode(JJTREFERENCETYPELIST);
179     boolean jjtc000 = true;
180     jjtree.openNodeScope(jjtn000);Token tok;
181     Token tok1;
182     Token tok2;
183     Token tok3;
184     try {
185       tok = jj_consume_token(LT);
186     if (!jdk1_5) {
187       {if (true) throw new ParseException("Generic reference types are only available in JDK 1.5 or later generics" );}
188     }
189       ActualTypeArgument();
190       label_1:
191       while (true) {
192         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
193         case COMMA:
194           ;
195           break;
196         default:
197           jj_la1[0] = jj_gen;
198           break label_1;
199         }
200         tok = jj_consume_token(COMMA);
201         ActualTypeArgument();
202       }
203       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
204       case GT:
205         tok = jj_consume_token(GT);
206         break;
207       case RSIGNEDSHIFT:
208         tok = jj_consume_token(RSIGNEDSHIFT);
209                  jjtree.closeNodeScope(jjtn000, true);
210                  jjtc000 = false;
211       tok2=tok.next;
212       tok1=Token.newToken(GT);
213       tok.image=">"; tok.kind=GT; tok.next=tok1;
214       tok1.image=">"; tok1.kind=GT; tok1.next=tok2;
215         break;
216       case RUNSIGNEDSHIFT:
217         tok = jj_consume_token(RUNSIGNEDSHIFT);
218                   jjtree.closeNodeScope(jjtn000, true);
219                   jjtc000 = false;
220       tok3=tok.next;
221       tok1=Token.newToken(GT); tok2=Token.newToken(GT);
222       tok.image=">"; tok.kind=GT; tok.next=tok1;
223       tok1.image=">"; tok1.kind=GT; tok1.next=tok2;
224       tok2.image=">"; tok2.kind=GT; tok2.next=tok3;
225         break;
226       default:
227         jj_la1[1] = jj_gen;
228         jj_consume_token(-1);
229         throw new ParseException();
230       }
231     } catch (Throwable JavaDoc jjte000) {
232     if (jjtc000) {
233       jjtree.clearNodeScope(jjtn000);
234       jjtc000 = false;
235     } else {
236       jjtree.popNode();
237     }
238     if (jjte000 instanceof RuntimeException JavaDoc) {
239       {if (true) throw (RuntimeException JavaDoc)jjte000;}
240     }
241     if (jjte000 instanceof ParseException) {
242       {if (true) throw (ParseException)jjte000;}
243     }
244     {if (true) throw (Error JavaDoc)jjte000;}
245     } finally {
246     if (jjtc000) {
247       jjtree.closeNodeScope(jjtn000, true);
248     }
249     }
250   }
251
252   final public void ActualTypeArgument() throws ParseException {
253  /*@bgen(jjtree) ActualTypeArgument */
254     SimpleNode jjtn000 = new SimpleNode(JJTACTUALTYPEARGUMENT);
255     boolean jjtc000 = true;
256     jjtree.openNodeScope(jjtn000);Token tok;
257     try {
258       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
259       case HOOK:
260         // Wildcard
261
tok = jj_consume_token(HOOK);
262                               jjtn000.setAttribute("wildcard", tok);
263         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
264         case EXTENDS:
265         case SUPER:
266           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
267           case EXTENDS:
268             tok = jj_consume_token(EXTENDS);
269                               jjtn000.setAttribute("token", tok);
270             break;
271           case SUPER:
272             tok = jj_consume_token(SUPER);
273                               jjtn000.setAttribute("token", tok);
274             break;
275           default:
276             jj_la1[2] = jj_gen;
277             jj_consume_token(-1);
278             throw new ParseException();
279           }
280           ReferenceType();
281           break;
282         default:
283           jj_la1[3] = jj_gen;
284           ;
285         }
286         break;
287       case BOOLEAN:
288       case BYTE:
289       case CHAR:
290       case DOUBLE:
291       case FLOAT:
292       case INT:
293       case LONG:
294       case SHORT:
295       case IDENTIFIER:
296         ReferenceType();
297         break;
298       default:
299         jj_la1[4] = jj_gen;
300         jj_consume_token(-1);
301         throw new ParseException();
302       }
303     } catch (Throwable JavaDoc jjte000) {
304     if (jjtc000) {
305       jjtree.clearNodeScope(jjtn000);
306       jjtc000 = false;
307     } else {
308       jjtree.popNode();
309     }
310     if (jjte000 instanceof RuntimeException JavaDoc) {
311       {if (true) throw (RuntimeException JavaDoc)jjte000;}
312     }
313     if (jjte000 instanceof ParseException) {
314       {if (true) throw (ParseException)jjte000;}
315     }
316     {if (true) throw (Error JavaDoc)jjte000;}
317     } finally {
318     if (jjtc000) {
319       jjtree.closeNodeScope(jjtn000, true);
320     }
321     }
322   }
323
324   final public void Identifier() throws ParseException {
325  /*@bgen(jjtree) Identifier */
326     SimpleNode jjtn000 = new SimpleNode(JJTIDENTIFIER);
327     boolean jjtc000 = true;
328     jjtree.openNodeScope(jjtn000);Token tok;
329     try {
330       tok = jj_consume_token(IDENTIFIER);
331       jjtree.closeNodeScope(jjtn000, true);
332       jjtc000 = false;
333       jjtn000.setAttribute("token", tok);
334     } finally {
335       if (jjtc000) {
336         jjtree.closeNodeScope(jjtn000, true);
337       }
338     }
339   }
340
341   final public void VariableInitializer() throws ParseException {
342     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
343     case LBRACE:
344       ArrayInitializer();
345       break;
346     default:
347       jj_la1[5] = jj_gen;
348       if (jj_2_1(1)) {
349         Expression();
350       } else {
351         jj_consume_token(-1);
352         throw new ParseException();
353       }
354     }
355   }
356
357   final public void ArrayInitializer() throws ParseException {
358                            /*@bgen(jjtree) ArrayInitializer */
359   SimpleNode jjtn000 = new SimpleNode(JJTARRAYINITIALIZER);
360   boolean jjtc000 = true;
361   jjtree.openNodeScope(jjtn000);
362     try {
363       jj_consume_token(LBRACE);
364       if (jj_2_3(1)) {
365         VariableInitializer();
366         label_2:
367         while (true) {
368           if (jj_2_2(2)) {
369             ;
370           } else {
371             break label_2;
372           }
373           jj_consume_token(COMMA);
374           VariableInitializer();
375         }
376       } else {
377         ;
378       }
379       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
380       case COMMA:
381         jj_consume_token(COMMA);
382         break;
383       default:
384         jj_la1[6] = jj_gen;
385         ;
386       }
387       jj_consume_token(RBRACE);
388     } catch (Throwable JavaDoc jjte000) {
389     if (jjtc000) {
390       jjtree.clearNodeScope(jjtn000);
391       jjtc000 = false;
392     } else {
393       jjtree.popNode();
394     }
395     if (jjte000 instanceof RuntimeException JavaDoc) {
396       {if (true) throw (RuntimeException JavaDoc)jjte000;}
397     }
398     if (jjte000 instanceof ParseException) {
399       {if (true) throw (ParseException)jjte000;}
400     }
401     {if (true) throw (Error JavaDoc)jjte000;}
402     } finally {
403     if (jjtc000) {
404       jjtree.closeNodeScope(jjtn000, true);
405     }
406     }
407   }
408
409 /*
410  * Type, name and expression syntax follows.
411  */

412   final public void Type() throws ParseException {
413     if (jj_2_4(2)) {
414       ReferenceType();
415     } else {
416       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
417       case BOOLEAN:
418       case BYTE:
419       case CHAR:
420       case DOUBLE:
421       case FLOAT:
422       case INT:
423       case LONG:
424       case SHORT:
425         PrimitiveType();
426         break;
427       default:
428         jj_la1[7] = jj_gen;
429         jj_consume_token(-1);
430         throw new ParseException();
431       }
432     }
433   }
434
435   final public void ReferenceType() throws ParseException {
436  /*@bgen(jjtree) ReferenceType */
437     SimpleNode jjtn000 = new SimpleNode(JJTREFERENCETYPE);
438     boolean jjtc000 = true;
439     jjtree.openNodeScope(jjtn000);int arrayCount = 0;
440     try {
441       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
442       case IDENTIFIER:
443         ClassOrInterfaceType();
444         label_3:
445         while (true) {
446           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
447           case LBRACKET:
448             ;
449             break;
450           default:
451             jj_la1[8] = jj_gen;
452             break label_3;
453           }
454           jj_consume_token(LBRACKET);
455           jj_consume_token(RBRACKET);
456          arrayCount++;
457         }
458         jjtree.closeNodeScope(jjtn000, true);
459         jjtc000 = false;
460         jjtn000.setAttribute("arrayCount", new Integer JavaDoc(arrayCount));
461         break;
462       case BOOLEAN:
463       case BYTE:
464       case CHAR:
465       case DOUBLE:
466       case FLOAT:
467       case INT:
468       case LONG:
469       case SHORT:
470         PrimitiveType();
471         label_4:
472         while (true) {
473           jj_consume_token(LBRACKET);
474           jj_consume_token(RBRACKET);
475          arrayCount++;
476           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
477           case LBRACKET:
478             ;
479             break;
480           default:
481             jj_la1[9] = jj_gen;
482             break label_4;
483           }
484         }
485         jjtree.closeNodeScope(jjtn000, true);
486         jjtc000 = false;
487         jjtn000.setAttribute("arrayCount", new Integer JavaDoc(arrayCount));
488         break;
489       default:
490         jj_la1[10] = jj_gen;
491         jj_consume_token(-1);
492         throw new ParseException();
493       }
494     } catch (Throwable JavaDoc jjte000) {
495       if (jjtc000) {
496         jjtree.clearNodeScope(jjtn000);
497         jjtc000 = false;
498       } else {
499         jjtree.popNode();
500       }
501       if (jjte000 instanceof RuntimeException JavaDoc) {
502         {if (true) throw (RuntimeException JavaDoc)jjte000;}
503       }
504       if (jjte000 instanceof ParseException) {
505         {if (true) throw (ParseException)jjte000;}
506       }
507       {if (true) throw (Error JavaDoc)jjte000;}
508     } finally {
509       if (jjtc000) {
510         jjtree.closeNodeScope(jjtn000, true);
511       }
512     }
513   }
514
515   final public void TypeArguments() throws ParseException {
516  /*@bgen(jjtree) TypeArguments */
517     SimpleNode jjtn000 = new SimpleNode(JJTTYPEARGUMENTS);
518     boolean jjtc000 = true;
519     jjtree.openNodeScope(jjtn000);Token tok;
520     Token tok1;
521     Token tok2;
522     Token tok3;
523     try {
524       tok = jj_consume_token(LT);
525     if (!jdk1_5) {
526       {if (true) throw new ParseException("Generic type arguments are only available in JDK 1.5 or later generics" );}
527     }
528       ActualTypeArgument();
529       label_5:
530       while (true) {
531         if (jj_2_5(2)) {
532           ;
533         } else {
534           break label_5;
535         }
536         tok = jj_consume_token(COMMA);
537         ActualTypeArgument();
538       }
539       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
540       case GT:
541         tok = jj_consume_token(GT);
542         break;
543       case RSIGNEDSHIFT:
544         tok = jj_consume_token(RSIGNEDSHIFT);
545                  jjtree.closeNodeScope(jjtn000, true);
546                  jjtc000 = false;
547         tok2=tok.next;
548         tok1=Token.newToken(GT);
549         tok.image=">"; tok.kind=GT; tok.next=tok1;
550         tok1.image=">"; tok1.kind=GT; tok1.next=tok2;
551         break;
552       case RUNSIGNEDSHIFT:
553         tok = jj_consume_token(RUNSIGNEDSHIFT);
554                   jjtree.closeNodeScope(jjtn000, true);
555                   jjtc000 = false;
556         tok3=tok.next;
557         tok1=Token.newToken(GT); tok2=Token.newToken(GT);
558         tok.image=">"; tok.kind=GT; tok.next=tok1;
559         tok1.image=">"; tok1.kind=GT; tok1.next=tok2;
560         tok2.image=">"; tok2.kind=GT; tok2.next=tok3;
561         break;
562       default:
563         jj_la1[11] = 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   final public void PrimitiveType() throws ParseException {
589  /*@bgen(jjtree) PrimitiveType */
590     SimpleNode jjtn000 = new SimpleNode(JJTPRIMITIVETYPE);
591     boolean jjtc000 = true;
592     jjtree.openNodeScope(jjtn000);Token tok;
593     try {
594       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
595       case BOOLEAN:
596         tok = jj_consume_token(BOOLEAN);
597         break;
598       case CHAR:
599         tok = jj_consume_token(CHAR);
600         break;
601       case BYTE:
602         tok = jj_consume_token(BYTE);
603         break;
604       case SHORT:
605         tok = jj_consume_token(SHORT);
606         break;
607       case INT:
608         tok = jj_consume_token(INT);
609         break;
610       case LONG:
611         tok = jj_consume_token(LONG);
612         break;
613       case FLOAT:
614         tok = jj_consume_token(FLOAT);
615         break;
616       case DOUBLE:
617         tok = jj_consume_token(DOUBLE);
618         break;
619       default:
620         jj_la1[12] = jj_gen;
621         jj_consume_token(-1);
622         throw new ParseException();
623       }
624     jjtree.closeNodeScope(jjtn000, true);
625     jjtc000 = false;
626     jjtn000.setAttribute("token", tok);
627     } finally {
628   if (jjtc000) {
629     jjtree.closeNodeScope(jjtn000, true);
630   }
631     }
632   }
633
634   final public void ResultType() throws ParseException {
635                      /*@bgen(jjtree) ResultType */
636   SimpleNode jjtn000 = new SimpleNode(JJTRESULTTYPE);
637   boolean jjtc000 = true;
638   jjtree.openNodeScope(jjtn000);
639     try {
640       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
641       case VOID:
642         jj_consume_token(VOID);
643               jjtree.closeNodeScope(jjtn000, true);
644               jjtc000 = false;
645               jjtn000.setAttribute("void", "void");
646         break;
647       case BOOLEAN:
648       case BYTE:
649       case CHAR:
650       case DOUBLE:
651       case FLOAT:
652       case INT:
653       case LONG:
654       case SHORT:
655       case IDENTIFIER:
656         Type();
657         break;
658       default:
659         jj_la1[13] = jj_gen;
660         jj_consume_token(-1);
661         throw new ParseException();
662       }
663     } catch (Throwable JavaDoc jjte000) {
664     if (jjtc000) {
665       jjtree.clearNodeScope(jjtn000);
666       jjtc000 = false;
667     } else {
668       jjtree.popNode();
669     }
670     if (jjte000 instanceof RuntimeException JavaDoc) {
671       {if (true) throw (RuntimeException JavaDoc)jjte000;}
672     }
673     if (jjte000 instanceof ParseException) {
674       {if (true) throw (ParseException)jjte000;}
675     }
676     {if (true) throw (Error JavaDoc)jjte000;}
677     } finally {
678     if (jjtc000) {
679       jjtree.closeNodeScope(jjtn000, true);
680     }
681     }
682   }
683
684   final public void Name() throws ParseException {
685  /*@bgen(jjtree) Name */
686     SimpleNode jjtn000 = new SimpleNode(JJTNAME);
687     boolean jjtc000 = true;
688     jjtree.openNodeScope(jjtn000);Token tok;
689     try {
690       tok = jj_consume_token(IDENTIFIER);
691     jjtn000.addAttribute("token", tok);
692       label_6:
693       while (true) {
694         if (jj_2_6(2)) {
695           ;
696         } else {
697           break label_6;
698         }
699         jj_consume_token(DOT);
700         tok = jj_consume_token(IDENTIFIER);
701       jjtn000.addAttribute("token", tok);
702       }
703     } finally {
704     if (jjtc000) {
705       jjtree.closeNodeScope(jjtn000, true);
706     }
707     }
708   }
709
710   final public void ClassOrInterfaceType() throws ParseException {
711                                /*@bgen(jjtree) ClassOrInterfaceType */
712   SimpleNode jjtn000 = new SimpleNode(JJTCLASSORINTERFACETYPE);
713   boolean jjtc000 = true;
714   jjtree.openNodeScope(jjtn000);
715     try {
716       Identifier();
717       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
718       case LT:
719         TypeArguments();
720         break;
721       default:
722         jj_la1[14] = jj_gen;
723         ;
724       }
725       label_7:
726       while (true) {
727         if (jj_2_7(2147483647)) {
728           ;
729         } else {
730           break label_7;
731         }
732         jj_consume_token(DOT);
733         Identifier();
734         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
735         case LT:
736           TypeArguments();
737           break;
738         default:
739           jj_la1[15] = jj_gen;
740           ;
741         }
742       }
743     } catch (Throwable JavaDoc jjte000) {
744     if (jjtc000) {
745       jjtree.clearNodeScope(jjtn000);
746       jjtc000 = false;
747     } else {
748       jjtree.popNode();
749     }
750     if (jjte000 instanceof RuntimeException JavaDoc) {
751       {if (true) throw (RuntimeException JavaDoc)jjte000;}
752     }
753     if (jjte000 instanceof ParseException) {
754       {if (true) throw (ParseException)jjte000;}
755     }
756     {if (true) throw (Error JavaDoc)jjte000;}
757     } finally {
758     if (jjtc000) {
759       jjtree.closeNodeScope(jjtn000, true);
760     }
761     }
762   }
763
764 /*
765  * Expression syntax follows.
766  */

767   final public SimpleNode Expression() throws ParseException {
768  /*@bgen(jjtree) Expression */
769   SimpleNode jjtn000 = new SimpleNode(JJTEXPRESSION);
770   boolean jjtc000 = true;
771   jjtree.openNodeScope(jjtn000);
772     try {
773       ConditionalExpression();
774       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
775       case ASSIGN:
776       case PLUSASSIGN:
777       case MINUSASSIGN:
778       case STARASSIGN:
779       case SLASHASSIGN:
780       case ANDASSIGN:
781       case ORASSIGN:
782       case XORASSIGN:
783       case REMASSIGN:
784       case LSHIFTASSIGN:
785       case RSIGNEDSHIFTASSIGN:
786       case RUNSIGNEDSHIFTASSIGN:
787         AssignmentOperator();
788         Expression();
789         break;
790       default:
791         jj_la1[16] = jj_gen;
792         ;
793       }
794     jjtree.closeNodeScope(jjtn000, true);
795     jjtc000 = false;
796     {if (true) return jjtn000;}
797     } catch (Throwable JavaDoc jjte000) {
798     if (jjtc000) {
799       jjtree.clearNodeScope(jjtn000);
800       jjtc000 = false;
801     } else {
802       jjtree.popNode();
803     }
804     if (jjte000 instanceof RuntimeException JavaDoc) {
805       {if (true) throw (RuntimeException JavaDoc)jjte000;}
806     }
807     if (jjte000 instanceof ParseException) {
808       {if (true) throw (ParseException)jjte000;}
809     }
810     {if (true) throw (Error JavaDoc)jjte000;}
811     } finally {
812     if (jjtc000) {
813       jjtree.closeNodeScope(jjtn000, true);
814     }
815     }
816     throw new Error JavaDoc("Missing return statement in function");
817   }
818
819   final public void AssignmentOperator() throws ParseException {
820  /*@bgen(jjtree) AssignmentOperator */
821     SimpleNode jjtn000 = new SimpleNode(JJTASSIGNMENTOPERATOR);
822     boolean jjtc000 = true;
823     jjtree.openNodeScope(jjtn000);Token tok;
824     try {
825       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
826       case ASSIGN:
827         tok = jj_consume_token(ASSIGN);
828         break;
829       case STARASSIGN:
830         tok = jj_consume_token(STARASSIGN);
831         break;
832       case SLASHASSIGN:
833         tok = jj_consume_token(SLASHASSIGN);
834         break;
835       case REMASSIGN:
836         tok = jj_consume_token(REMASSIGN);
837         break;
838       case PLUSASSIGN:
839         tok = jj_consume_token(PLUSASSIGN);
840         break;
841       case MINUSASSIGN:
842         tok = jj_consume_token(MINUSASSIGN);
843         break;
844       case LSHIFTASSIGN:
845         tok = jj_consume_token(LSHIFTASSIGN);
846         break;
847       case RSIGNEDSHIFTASSIGN:
848         tok = jj_consume_token(RSIGNEDSHIFTASSIGN);
849         break;
850       case RUNSIGNEDSHIFTASSIGN:
851         tok = jj_consume_token(RUNSIGNEDSHIFTASSIGN);
852         break;
853       case ANDASSIGN:
854         tok = jj_consume_token(ANDASSIGN);
855         break;
856       case XORASSIGN:
857         tok = jj_consume_token(XORASSIGN);
858         break;
859       case ORASSIGN:
860         tok = jj_consume_token(ORASSIGN);
861         break;
862       default:
863         jj_la1[17] = jj_gen;
864         jj_consume_token(-1);
865         throw new ParseException();
866       }
867       jjtree.closeNodeScope(jjtn000, true);
868       jjtc000 = false;
869         jjtn000.setAttribute("operator", tok);
870     } finally {
871     if (jjtc000) {
872       jjtree.closeNodeScope(jjtn000, true);
873     }
874     }
875   }
876
877   final public void ConditionalExpression() throws ParseException {
878   SimpleNode jjtn001 = new SimpleNode(JJTCONDITIONALEXPRESSION);
879   boolean jjtc001 = true;
880   jjtree.openNodeScope(jjtn001);
881     try {
882       ConditionalOrExpression();
883       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
884       case HOOK:
885         jj_consume_token(HOOK);
886         Expression();
887         jj_consume_token(COLON);
888         ConditionalExpression();
889         break;
890       default:
891         jj_la1[18] = jj_gen;
892         ;
893       }
894     } catch (Throwable JavaDoc jjte001) {
895   if (jjtc001) {
896     jjtree.clearNodeScope(jjtn001);
897     jjtc001 = false;
898   } else {
899     jjtree.popNode();
900   }
901   if (jjte001 instanceof RuntimeException JavaDoc) {
902     {if (true) throw (RuntimeException JavaDoc)jjte001;}
903   }
904   if (jjte001 instanceof ParseException) {
905     {if (true) throw (ParseException)jjte001;}
906   }
907   {if (true) throw (Error JavaDoc)jjte001;}
908     } finally {
909   if (jjtc001) {
910     jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
911   }
912     }
913   }
914
915   final public void ConditionalOrExpression() throws ParseException {
916     Token tok;
917   SimpleNode jjtn001 = new SimpleNode(JJTCONDITIONALOREXPRESSION);
918   boolean jjtc001 = true;
919   jjtree.openNodeScope(jjtn001);
920     try {
921       ConditionalAndExpression();
922       label_8:
923       while (true) {
924         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
925         case SC_OR:
926           ;
927           break;
928         default:
929           jj_la1[19] = jj_gen;
930           break label_8;
931         }
932         tok = jj_consume_token(SC_OR);
933                                   jjtn001.setAttribute("operator", tok);
934         ConditionalAndExpression();
935       }
936     } catch (Throwable JavaDoc jjte001) {
937   if (jjtc001) {
938     jjtree.clearNodeScope(jjtn001);
939     jjtc001 = false;
940   } else {
941     jjtree.popNode();
942   }
943   if (jjte001 instanceof RuntimeException JavaDoc) {
944     {if (true) throw (RuntimeException JavaDoc)jjte001;}
945   }
946   if (jjte001 instanceof ParseException) {
947     {if (true) throw (ParseException)jjte001;}
948   }
949   {if (true) throw (Error JavaDoc)jjte001;}
950     } finally {
951   if (jjtc001) {
952     jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
953   }
954     }
955   }
956
957   final public void ConditionalAndExpression() throws ParseException {
958     Token tok;
959   SimpleNode jjtn001 = new SimpleNode(JJTCONDITIONALANDEXPRESSION);
960   boolean jjtc001 = true;
961   jjtree.openNodeScope(jjtn001);
962     try {
963       InclusiveOrExpression();
964       label_9:
965       while (true) {
966         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
967         case SC_AND:
968           ;
969           break;
970         default:
971           jj_la1[20] = jj_gen;
972           break label_9;
973         }
974         tok = jj_consume_token(SC_AND);
975                                   jjtn001.setAttribute("operator", tok);
976         InclusiveOrExpression();
977       }
978     } catch (Throwable JavaDoc jjte001) {
979   if (jjtc001) {
980     jjtree.clearNodeScope(jjtn001);
981     jjtc001 = false;
982   } else {
983     jjtree.popNode();
984   }
985   if (jjte001 instanceof RuntimeException JavaDoc) {
986     {if (true) throw (RuntimeException JavaDoc)jjte001;}
987   }
988   if (jjte001 instanceof ParseException) {
989     {if (true) throw (ParseException)jjte001;}
990   }
991   {if (true) throw (Error JavaDoc)jjte001;}
992     } finally {
993   if (jjtc001) {
994     jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
995   }
996     }
997   }
998
999   final public void InclusiveOrExpression() throws ParseException {
1000    Token tok;
1001  SimpleNode jjtn001 = new SimpleNode(JJTINCLUSIVEOREXPRESSION);
1002  boolean jjtc001 = true;
1003  jjtree.openNodeScope(jjtn001);
1004    try {
1005      ExclusiveOrExpression();
1006      label_10:
1007      while (true) {
1008        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1009        case BIT_OR:
1010          ;
1011          break;
1012        default:
1013          jj_la1[21] = jj_gen;
1014          break label_10;
1015        }
1016        tok = jj_consume_token(BIT_OR);
1017                                  jjtn001.addAttribute("operator", tok);
1018        ExclusiveOrExpression();
1019      }
1020    } catch (Throwable JavaDoc jjte001) {
1021  if (jjtc001) {
1022    jjtree.clearNodeScope(jjtn001);
1023    jjtc001 = false;
1024  } else {
1025    jjtree.popNode();
1026  }
1027  if (jjte001 instanceof RuntimeException JavaDoc) {
1028    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1029  }
1030  if (jjte001 instanceof ParseException) {
1031    {if (true) throw (ParseException)jjte001;}
1032  }
1033  {if (true) throw (Error JavaDoc)jjte001;}
1034    } finally {
1035  if (jjtc001) {
1036    jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1037  }
1038    }
1039  }
1040
1041  final public void ExclusiveOrExpression() throws ParseException {
1042    Token tok;
1043  SimpleNode jjtn001 = new SimpleNode(JJTEXCLUSIVEOREXPRESSION);
1044  boolean jjtc001 = true;
1045  jjtree.openNodeScope(jjtn001);
1046    try {
1047      AndExpression();
1048      label_11:
1049      while (true) {
1050        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1051        case XOR:
1052          ;
1053          break;
1054        default:
1055          jj_la1[22] = jj_gen;
1056          break label_11;
1057        }
1058        tok = jj_consume_token(XOR);
1059                                  jjtn001.addAttribute("operator", tok);
1060        AndExpression();
1061      }
1062    } catch (Throwable JavaDoc jjte001) {
1063  if (jjtc001) {
1064    jjtree.clearNodeScope(jjtn001);
1065    jjtc001 = false;
1066  } else {
1067    jjtree.popNode();
1068  }
1069  if (jjte001 instanceof RuntimeException JavaDoc) {
1070    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1071  }
1072  if (jjte001 instanceof ParseException) {
1073    {if (true) throw (ParseException)jjte001;}
1074  }
1075  {if (true) throw (Error JavaDoc)jjte001;}
1076    } finally {
1077  if (jjtc001) {
1078    jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1079  }
1080    }
1081  }
1082
1083  final public void AndExpression() throws ParseException {
1084    Token tok;
1085  SimpleNode jjtn001 = new SimpleNode(JJTANDEXPRESSION);
1086  boolean jjtc001 = true;
1087  jjtree.openNodeScope(jjtn001);
1088    try {
1089      EqualityExpression();
1090      label_12:
1091      while (true) {
1092        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1093        case BIT_AND:
1094          ;
1095          break;
1096        default:
1097          jj_la1[23] = jj_gen;
1098          break label_12;
1099        }
1100        tok = jj_consume_token(BIT_AND);
1101                                  jjtn001.addAttribute("operator", tok);
1102        EqualityExpression();
1103      }
1104    } catch (Throwable JavaDoc jjte001) {
1105  if (jjtc001) {
1106    jjtree.clearNodeScope(jjtn001);
1107    jjtc001 = false;
1108  } else {
1109    jjtree.popNode();
1110  }
1111  if (jjte001 instanceof RuntimeException JavaDoc) {
1112    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1113  }
1114  if (jjte001 instanceof ParseException) {
1115    {if (true) throw (ParseException)jjte001;}
1116  }
1117  {if (true) throw (Error JavaDoc)jjte001;}
1118    } finally {
1119  if (jjtc001) {
1120    jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1121  }
1122    }
1123  }
1124
1125  final public void EqualityExpression() throws ParseException {
1126    Token tok;
1127  SimpleNode jjtn001 = new SimpleNode(JJTEQUALITYEXPRESSION);
1128  boolean jjtc001 = true;
1129  jjtree.openNodeScope(jjtn001);
1130    try {
1131      InstanceOfExpression();
1132      label_13:
1133      while (true) {
1134        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1135        case EQ:
1136        case NE:
1137          ;
1138          break;
1139        default:
1140          jj_la1[24] = jj_gen;
1141          break label_13;
1142        }
1143        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1144        case EQ:
1145          tok = jj_consume_token(EQ);
1146          break;
1147        case NE:
1148          tok = jj_consume_token(NE);
1149          break;
1150        default:
1151          jj_la1[25] = jj_gen;
1152          jj_consume_token(-1);
1153          throw new ParseException();
1154        }
1155                                  jjtn001.addAttribute("operator", tok);
1156        InstanceOfExpression();
1157      }
1158    } catch (Throwable JavaDoc jjte001) {
1159  if (jjtc001) {
1160    jjtree.clearNodeScope(jjtn001);
1161    jjtc001 = false;
1162  } else {
1163    jjtree.popNode();
1164  }
1165  if (jjte001 instanceof RuntimeException JavaDoc) {
1166    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1167  }
1168  if (jjte001 instanceof ParseException) {
1169    {if (true) throw (ParseException)jjte001;}
1170  }
1171  {if (true) throw (Error JavaDoc)jjte001;}
1172    } finally {
1173  if (jjtc001) {
1174    jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1175  }
1176    }
1177  }
1178
1179  final public void InstanceOfExpression() throws ParseException {
1180  SimpleNode jjtn001 = new SimpleNode(JJTINSTANCEOFEXPRESSION);
1181  boolean jjtc001 = true;
1182  jjtree.openNodeScope(jjtn001);
1183    try {
1184      RelationalExpression();
1185      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1186      case INSTANCEOF:
1187        jj_consume_token(INSTANCEOF);
1188        ReferenceType();
1189        break;
1190      default:
1191        jj_la1[26] = jj_gen;
1192        ;
1193      }
1194    } catch (Throwable JavaDoc jjte001) {
1195  if (jjtc001) {
1196    jjtree.clearNodeScope(jjtn001);
1197    jjtc001 = false;
1198  } else {
1199    jjtree.popNode();
1200  }
1201  if (jjte001 instanceof RuntimeException JavaDoc) {
1202    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1203  }
1204  if (jjte001 instanceof ParseException) {
1205    {if (true) throw (ParseException)jjte001;}
1206  }
1207  {if (true) throw (Error JavaDoc)jjte001;}
1208    } finally {
1209  if (jjtc001) {
1210    jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1211  }
1212    }
1213  }
1214
1215  final public void RelationalExpression() throws ParseException {
1216  SimpleNode jjtn001 = new SimpleNode(JJTRELATIONALEXPRESSION);
1217  boolean jjtc001 = true;
1218  jjtree.openNodeScope(jjtn001);
1219    try {
1220      ShiftExpression();
1221      label_14:
1222      while (true) {
1223        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1224        case GT:
1225        case LT:
1226        case LE:
1227        case GE:
1228          ;
1229          break;
1230        default:
1231          jj_la1[27] = jj_gen;
1232          break label_14;
1233        }
1234        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1235        case LT:
1236          jj_consume_token(LT);
1237          break;
1238        case GT:
1239          jj_consume_token(GT);
1240          break;
1241        case LE:
1242          jj_consume_token(LE);
1243          break;
1244        case GE:
1245          jj_consume_token(GE);
1246          break;
1247        default:
1248          jj_la1[28] = jj_gen;
1249          jj_consume_token(-1);
1250          throw new ParseException();
1251        }
1252      jjtn001.addAttribute("operator", token);
1253        ShiftExpression();
1254      }
1255    } catch (Throwable JavaDoc jjte001) {
1256  if (jjtc001) {
1257    jjtree.clearNodeScope(jjtn001);
1258    jjtc001 = false;
1259  } else {
1260    jjtree.popNode();
1261  }
1262  if (jjte001 instanceof RuntimeException JavaDoc) {
1263    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1264  }
1265  if (jjte001 instanceof ParseException) {
1266    {if (true) throw (ParseException)jjte001;}
1267  }
1268  {if (true) throw (Error JavaDoc)jjte001;}
1269    } finally {
1270  if (jjtc001) {
1271    jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1272  }
1273    }
1274  }
1275
1276  final public void ShiftExpression() throws ParseException {
1277    Token tok;
1278  SimpleNode jjtn001 = new SimpleNode(JJTSHIFTEXPRESSION);
1279  boolean jjtc001 = true;
1280  jjtree.openNodeScope(jjtn001);
1281    try {
1282      AdditiveExpression();
1283      label_15:
1284      while (true) {
1285        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1286        case LSHIFT:
1287        case RSIGNEDSHIFT:
1288        case RUNSIGNEDSHIFT:
1289          ;
1290          break;
1291        default:
1292          jj_la1[29] = jj_gen;
1293          break label_15;
1294        }
1295        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1296        case LSHIFT:
1297          tok = jj_consume_token(LSHIFT);
1298          break;
1299        case RSIGNEDSHIFT:
1300          tok = jj_consume_token(RSIGNEDSHIFT);
1301          break;
1302        case RUNSIGNEDSHIFT:
1303          tok = jj_consume_token(RUNSIGNEDSHIFT);
1304          break;
1305        default:
1306          jj_la1[30] = jj_gen;
1307          jj_consume_token(-1);
1308          throw new ParseException();
1309        }
1310        jjtn001.addAttribute("operator", tok);
1311        AdditiveExpression();
1312      }
1313    } catch (Throwable JavaDoc jjte001) {
1314  if (jjtc001) {
1315    jjtree.clearNodeScope(jjtn001);
1316    jjtc001 = false;
1317  } else {
1318    jjtree.popNode();
1319  }
1320  if (jjte001 instanceof RuntimeException JavaDoc) {
1321    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1322  }
1323  if (jjte001 instanceof ParseException) {
1324    {if (true) throw (ParseException)jjte001;}
1325  }
1326  {if (true) throw (Error JavaDoc)jjte001;}
1327    } finally {
1328  if (jjtc001) {
1329    jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1330  }
1331    }
1332  }
1333
1334  final public void AdditiveExpression() throws ParseException {
1335    Token tok;
1336      SimpleNode jjtn001 = new SimpleNode(JJTADDITIVEEXPRESSION);
1337      boolean jjtc001 = true;
1338      jjtree.openNodeScope(jjtn001);
1339    try {
1340      MultiplicativeExpression();
1341      label_16:
1342      while (true) {
1343        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1344        case PLUS:
1345        case MINUS:
1346          ;
1347          break;
1348        default:
1349          jj_la1[31] = jj_gen;
1350          break label_16;
1351        }
1352        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1353        case PLUS:
1354          tok = jj_consume_token(PLUS);
1355          break;
1356        case MINUS:
1357          tok = jj_consume_token(MINUS);
1358          break;
1359        default:
1360          jj_la1[32] = jj_gen;
1361          jj_consume_token(-1);
1362          throw new ParseException();
1363        }
1364            jjtn001.addAttribute("operator", tok);
1365        MultiplicativeExpression();
1366      }
1367    } catch (Throwable JavaDoc jjte001) {
1368      if (jjtc001) {
1369        jjtree.clearNodeScope(jjtn001);
1370        jjtc001 = false;
1371      } else {
1372        jjtree.popNode();
1373      }
1374      if (jjte001 instanceof RuntimeException JavaDoc) {
1375        {if (true) throw (RuntimeException JavaDoc)jjte001;}
1376      }
1377      if (jjte001 instanceof ParseException) {
1378        {if (true) throw (ParseException)jjte001;}
1379      }
1380      {if (true) throw (Error JavaDoc)jjte001;}
1381    } finally {
1382      if (jjtc001) {
1383        jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1384      }
1385    }
1386  }
1387
1388  final public void MultiplicativeExpression() throws ParseException {
1389    Token tok;
1390  SimpleNode jjtn001 = new SimpleNode(JJTMULTIPLICATIVEEXPRESSION);
1391  boolean jjtc001 = true;
1392  jjtree.openNodeScope(jjtn001);
1393    try {
1394      UnaryExpression();
1395      label_17:
1396      while (true) {
1397        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1398        case STAR:
1399        case SLASH:
1400        case REM:
1401          ;
1402          break;
1403        default:
1404          jj_la1[33] = jj_gen;
1405          break label_17;
1406        }
1407        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1408        case STAR:
1409          tok = jj_consume_token(STAR);
1410          break;
1411        case SLASH:
1412          tok = jj_consume_token(SLASH);
1413          break;
1414        case REM:
1415          tok = jj_consume_token(REM);
1416          break;
1417        default:
1418          jj_la1[34] = jj_gen;
1419          jj_consume_token(-1);
1420          throw new ParseException();
1421        }
1422        jjtn001.addAttribute("operator", tok);
1423        UnaryExpression();
1424      }
1425    } catch (Throwable JavaDoc jjte001) {
1426  if (jjtc001) {
1427    jjtree.clearNodeScope(jjtn001);
1428    jjtc001 = false;
1429  } else {
1430    jjtree.popNode();
1431  }
1432  if (jjte001 instanceof RuntimeException JavaDoc) {
1433    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1434  }
1435  if (jjte001 instanceof ParseException) {
1436    {if (true) throw (ParseException)jjte001;}
1437  }
1438  {if (true) throw (Error JavaDoc)jjte001;}
1439    } finally {
1440  if (jjtc001) {
1441    jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1442  }
1443    }
1444  }
1445
1446  final public void UnaryExpression() throws ParseException {
1447    Token tok = null;
1448  SimpleNode jjtn001 = new SimpleNode(JJTUNARYEXPRESSION);
1449  boolean jjtc001 = true;
1450  jjtree.openNodeScope(jjtn001);
1451    try {
1452      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1453      case PLUS:
1454      case MINUS:
1455        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1456        case PLUS:
1457          tok = jj_consume_token(PLUS);
1458          break;
1459        case MINUS:
1460          tok = jj_consume_token(MINUS);
1461          break;
1462        default:
1463          jj_la1[35] = jj_gen;
1464          jj_consume_token(-1);
1465          throw new ParseException();
1466        }
1467      jjtn001.setAttribute("operator", tok);
1468        UnaryExpression();
1469        break;
1470      case INCR:
1471        PreIncrementExpression();
1472        break;
1473      case DECR:
1474        PreDecrementExpression();
1475        break;
1476      default:
1477        jj_la1[36] = jj_gen;
1478        if (jj_2_8(1)) {
1479          UnaryExpressionNotPlusMinus();
1480        } else {
1481          jj_consume_token(-1);
1482          throw new ParseException();
1483        }
1484      }
1485    } catch (Throwable JavaDoc jjte001) {
1486  if (jjtc001) {
1487    jjtree.clearNodeScope(jjtn001);
1488    jjtc001 = false;
1489  } else {
1490    jjtree.popNode();
1491  }
1492  if (jjte001 instanceof RuntimeException JavaDoc) {
1493    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1494  }
1495  if (jjte001 instanceof ParseException) {
1496    {if (true) throw (ParseException)jjte001;}
1497  }
1498  {if (true) throw (Error JavaDoc)jjte001;}
1499    } finally {
1500  if (jjtc001) {
1501    jjtree.closeNodeScope(jjtn001, tok != null);
1502  }
1503    }
1504  }
1505
1506  final public void PreIncrementExpression() throws ParseException {
1507 /*@bgen(jjtree) PreIncrementExpression */
1508    SimpleNode jjtn000 = new SimpleNode(JJTPREINCREMENTEXPRESSION);
1509    boolean jjtc000 = true;
1510    jjtree.openNodeScope(jjtn000);Token tok;
1511    try {
1512      tok = jj_consume_token(INCR);
1513             jjtn000.setAttribute("operator", tok);
1514      PrimaryExpression();
1515    } catch (Throwable JavaDoc jjte000) {
1516    if (jjtc000) {
1517      jjtree.clearNodeScope(jjtn000);
1518      jjtc000 = false;
1519    } else {
1520      jjtree.popNode();
1521    }
1522    if (jjte000 instanceof RuntimeException JavaDoc) {
1523      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1524    }
1525    if (jjte000 instanceof ParseException) {
1526      {if (true) throw (ParseException)jjte000;}
1527    }
1528    {if (true) throw (Error JavaDoc)jjte000;}
1529    } finally {
1530    if (jjtc000) {
1531      jjtree.closeNodeScope(jjtn000, true);
1532    }
1533    }
1534  }
1535
1536  final public void PreDecrementExpression() throws ParseException {
1537 /*@bgen(jjtree) PreDecrementExpression */
1538    SimpleNode jjtn000 = new SimpleNode(JJTPREDECREMENTEXPRESSION);
1539    boolean jjtc000 = true;
1540    jjtree.openNodeScope(jjtn000);Token tok;
1541    try {
1542      tok = jj_consume_token(DECR);
1543             jjtn000.setAttribute("operator", tok);
1544      PrimaryExpression();
1545    } catch (Throwable JavaDoc jjte000) {
1546    if (jjtc000) {
1547      jjtree.clearNodeScope(jjtn000);
1548      jjtc000 = false;
1549    } else {
1550      jjtree.popNode();
1551    }
1552    if (jjte000 instanceof RuntimeException JavaDoc) {
1553      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1554    }
1555    if (jjte000 instanceof ParseException) {
1556      {if (true) throw (ParseException)jjte000;}
1557    }
1558    {if (true) throw (Error JavaDoc)jjte000;}
1559    } finally {
1560    if (jjtc000) {
1561      jjtree.closeNodeScope(jjtn000, true);
1562    }
1563    }
1564  }
1565
1566  final public void UnaryExpressionNotPlusMinus() throws ParseException {
1567    Token tok = null;
1568  SimpleNode jjtn001 = new SimpleNode(JJTUNARYEXPRESSIONNOTPLUSMINUS);
1569  boolean jjtc001 = true;
1570  jjtree.openNodeScope(jjtn001);
1571    try {
1572      if (castLookahead()) {
1573        CastExpression();
1574      } else {
1575        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1576        case BANG:
1577        case TILDE:
1578          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1579          case TILDE:
1580            tok = jj_consume_token(TILDE);
1581            break;
1582          case BANG:
1583            tok = jj_consume_token(BANG);
1584            break;
1585          default:
1586            jj_la1[37] = jj_gen;
1587            jj_consume_token(-1);
1588            throw new ParseException();
1589          }
1590      jjtn001.setAttribute("operator", tok);
1591          UnaryExpression();
1592          break;
1593        case BOOLEAN:
1594        case BYTE:
1595        case CHAR:
1596        case DOUBLE:
1597        case FALSE:
1598        case FLOAT:
1599        case INT:
1600        case LONG:
1601        case NEW:
1602        case NULL:
1603        case SHORT:
1604        case SUPER:
1605        case THIS:
1606        case TRUE:
1607        case VOID:
1608        case INTEGER_LITERAL:
1609        case FLOATING_POINT_LITERAL:
1610        case CHARACTER_LITERAL:
1611        case STRING_LITERAL:
1612        case IDENTIFIER:
1613        case LPAREN:
1614          PostfixExpression();
1615          break;
1616        default:
1617          jj_la1[38] = jj_gen;
1618          jj_consume_token(-1);
1619          throw new ParseException();
1620        }
1621      }
1622    } catch (Throwable JavaDoc jjte001) {
1623  if (jjtc001) {
1624    jjtree.clearNodeScope(jjtn001);
1625    jjtc001 = false;
1626  } else {
1627    jjtree.popNode();
1628  }
1629  if (jjte001 instanceof RuntimeException JavaDoc) {
1630    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1631  }
1632  if (jjte001 instanceof ParseException) {
1633    {if (true) throw (ParseException)jjte001;}
1634  }
1635  {if (true) throw (Error JavaDoc)jjte001;}
1636    } finally {
1637  if (jjtc001) {
1638    jjtree.closeNodeScope(jjtn001, tok != null);
1639  }
1640    }
1641  }
1642
1643  final public void PostfixExpression() throws ParseException {
1644    Token tok = null;
1645  SimpleNode jjtn001 = new SimpleNode(JJTPOSTFIXEXPRESSION);
1646  boolean jjtc001 = true;
1647  jjtree.openNodeScope(jjtn001);
1648    try {
1649      PrimaryExpression();
1650      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1651      case INCR:
1652      case DECR:
1653        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1654        case INCR:
1655          tok = jj_consume_token(INCR);
1656          break;
1657        case DECR:
1658          tok = jj_consume_token(DECR);
1659          break;
1660        default:
1661          jj_la1[39] = jj_gen;
1662          jj_consume_token(-1);
1663          throw new ParseException();
1664        }
1665        break;
1666      default:
1667        jj_la1[40] = jj_gen;
1668        ;
1669      }
1670    jjtree.closeNodeScope(jjtn001, tok != null);
1671    jjtc001 = false;
1672    if (tok != null) jjtn001.setAttribute("operator", token);
1673    } catch (Throwable JavaDoc jjte001) {
1674  if (jjtc001) {
1675    jjtree.clearNodeScope(jjtn001);
1676    jjtc001 = false;
1677  } else {
1678    jjtree.popNode();
1679  }
1680  if (jjte001 instanceof RuntimeException JavaDoc) {
1681    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1682  }
1683  if (jjte001 instanceof ParseException) {
1684    {if (true) throw (ParseException)jjte001;}
1685  }
1686  {if (true) throw (Error JavaDoc)jjte001;}
1687    } finally {
1688  if (jjtc001) {
1689    jjtree.closeNodeScope(jjtn001, tok != null);
1690  }
1691    }
1692  }
1693
1694  final public void CastExpression() throws ParseException {
1695                         /*@bgen(jjtree) CastExpression */
1696  SimpleNode jjtn000 = new SimpleNode(JJTCASTEXPRESSION);
1697  boolean jjtc000 = true;
1698  jjtree.openNodeScope(jjtn000);
1699    try {
1700      jj_consume_token(LPAREN);
1701      Type();
1702      jj_consume_token(RPAREN);
1703      UnaryExpression();
1704    } catch (Throwable JavaDoc jjte000) {
1705    if (jjtc000) {
1706      jjtree.clearNodeScope(jjtn000);
1707      jjtc000 = false;
1708    } else {
1709      jjtree.popNode();
1710    }
1711    if (jjte000 instanceof RuntimeException JavaDoc) {
1712      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1713    }
1714    if (jjte000 instanceof ParseException) {
1715      {if (true) throw (ParseException)jjte000;}
1716    }
1717    {if (true) throw (Error JavaDoc)jjte000;}
1718    } finally {
1719    if (jjtc000) {
1720      jjtree.closeNodeScope(jjtn000, true);
1721    }
1722    }
1723  }
1724
1725  final public void PrimaryExpression() throws ParseException {
1726  SimpleNode jjtn001 = new SimpleNode(JJTPRIMARYEXPRESSION);
1727  boolean jjtc001 = true;
1728  jjtree.openNodeScope(jjtn001);
1729    try {
1730      PrimaryPrefix();
1731      label_18:
1732      while (true) {
1733        if (jj_2_9(2147483647)) {
1734          ;
1735        } else {
1736          break label_18;
1737        }
1738        PrimarySuffix();
1739      }
1740    } catch (Throwable JavaDoc jjte001) {
1741  if (jjtc001) {
1742    jjtree.clearNodeScope(jjtn001);
1743    jjtc001 = false;
1744  } else {
1745    jjtree.popNode();
1746  }
1747  if (jjte001 instanceof RuntimeException JavaDoc) {
1748    {if (true) throw (RuntimeException JavaDoc)jjte001;}
1749  }
1750  if (jjte001 instanceof ParseException) {
1751    {if (true) throw (ParseException)jjte001;}
1752  }
1753  {if (true) throw (Error JavaDoc)jjte001;}
1754    } finally {
1755  if (jjtc001) {
1756    jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 0);
1757  }
1758    }
1759  }
1760
1761  final public void PrimaryPrefix() throws ParseException {
1762 /*@bgen(jjtree) PrimaryPrefix */
1763  SimpleNode jjtn000 = new SimpleNode(JJTPRIMARYPREFIX);
1764  boolean jjtc000 = true;
1765  jjtree.openNodeScope(jjtn000);Token tok;
1766  String JavaDoc name = "";
1767    try {
1768      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1769      case FALSE:
1770      case NULL:
1771      case TRUE:
1772      case INTEGER_LITERAL:
1773      case FLOATING_POINT_LITERAL:
1774      case CHARACTER_LITERAL:
1775      case STRING_LITERAL:
1776        Literal();
1777        break;
1778      case THIS:
1779        tok = jj_consume_token(THIS);
1780               jjtree.closeNodeScope(jjtn000, true);
1781               jjtc000 = false;
1782               jjtn000.setAttribute("this", "this");
1783        break;
1784      default:
1785        jj_la1[42] = jj_gen;
1786        if (jj_2_10(2147483647)) {
1787          label_19:
1788          while (true) {
1789            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1790            case IDENTIFIER:
1791              ;
1792              break;
1793            default:
1794              jj_la1[41] = jj_gen;
1795              break label_19;
1796            }
1797            tok = jj_consume_token(IDENTIFIER);
1798            jj_consume_token(DOT);
1799        name = name + tok.image + ".";
1800          }
1801          jj_consume_token(SUPER);
1802          jj_consume_token(DOT);
1803          tok = jj_consume_token(IDENTIFIER);
1804    jjtree.closeNodeScope(jjtn000, true);
1805    jjtc000 = false;
1806    jjtn000.setAttribute("qualifier", (name.length() > 0) ? name.substring(0, name.length() - 1) : "");
1807    name = name + "super." + tok.image;
1808    jjtn000.setAttribute("identifier", tok.image);
1809        } else {
1810          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1811          case LPAREN:
1812            tok = jj_consume_token(LPAREN);
1813            Expression();
1814            tok = jj_consume_token(RPAREN);
1815            break;
1816          case NEW:
1817            AllocationExpression();
1818            break;
1819          default:
1820            jj_la1[43] = jj_gen;
1821            if (jj_2_11(2147483647)) {
1822              ResultType();
1823              jj_consume_token(DOT);
1824              jj_consume_token(CLASS);
1825            } else {
1826              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1827              case IDENTIFIER:
1828                Name();
1829                break;
1830              default:
1831                jj_la1[44] = jj_gen;
1832                jj_consume_token(-1);
1833                throw new ParseException();
1834              }
1835            }
1836          }
1837        }
1838      }
1839    } catch (Throwable JavaDoc jjte000) {
1840  if (jjtc000) {
1841    jjtree.clearNodeScope(jjtn000);
1842    jjtc000 = false;
1843  } else {
1844    jjtree.popNode();
1845  }
1846  if (jjte000 instanceof RuntimeException JavaDoc) {
1847    {if (true) throw (RuntimeException JavaDoc)jjte000;}
1848  }
1849  if (jjte000 instanceof ParseException) {
1850    {if (true) throw (ParseException)jjte000;}
1851  }
1852  {if (true) throw (Error JavaDoc)jjte000;}
1853    } finally {
1854  if (jjtc000) {
1855    jjtree.closeNodeScope(jjtn000, true);
1856  }
1857    }
1858  }
1859
1860  final public void PrimarySuffix() throws ParseException {
1861 /*@bgen(jjtree) PrimarySuffix */
1862    SimpleNode jjtn000 = new SimpleNode(JJTPRIMARYSUFFIX);
1863    boolean jjtc000 = true;
1864    jjtree.openNodeScope(jjtn000);Token tok;
1865    try {
1866      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1867      case DOT:
1868        tok = jj_consume_token(DOT);
1869        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1870        case THIS:
1871          tok = jj_consume_token(THIS);
1872                      jjtree.closeNodeScope(jjtn000, true);
1873                      jjtc000 = false;
1874                      jjtn000.setAttribute("token", tok);
1875          break;
1876        case SUPER:
1877          tok = jj_consume_token(SUPER);
1878                      jjtree.closeNodeScope(jjtn000, true);
1879                      jjtc000 = false;
1880                      jjtn000.setAttribute("token", tok);
1881          break;
1882        case NEW:
1883          AllocationExpression();
1884          break;
1885        case IDENTIFIER:
1886        case LT:
1887          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1888          case LT:
1889            ReferenceTypeList();
1890            break;
1891          default:
1892            jj_la1[45] = jj_gen;
1893            ;
1894          }
1895          tok = jj_consume_token(IDENTIFIER);
1896                         jjtree.closeNodeScope(jjtn000, true);
1897                         jjtc000 = false;
1898                         jjtn000.setAttribute("token", tok);
1899          break;
1900        default:
1901          jj_la1[46] = jj_gen;
1902          jj_consume_token(-1);
1903          throw new ParseException();
1904        }
1905        break;
1906      case LBRACKET:
1907        tok = jj_consume_token(LBRACKET);
1908                      jjtn000.setAttribute("token", tok);
1909        Expression();
1910        tok = jj_consume_token(RBRACKET);
1911        break;
1912      case LPAREN:
1913        Arguments();
1914        break;
1915      case LT:
1916        ReferenceTypeList();
1917        break;
1918      default:
1919        jj_la1[47] = jj_gen;
1920        jj_consume_token(-1);
1921        throw new ParseException();
1922      }
1923    } catch (Throwable JavaDoc jjte000) {
1924    if (jjtc000) {
1925      jjtree.clearNodeScope(jjtn000);
1926      jjtc000 = false;
1927    } else {
1928      jjtree.popNode();
1929    }
1930    if (jjte000 instanceof RuntimeException JavaDoc) {
1931      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1932    }
1933    if (jjte000 instanceof ParseException) {
1934      {if (true) throw (ParseException)jjte000;}
1935    }
1936    {if (true) throw (Error JavaDoc)jjte000;}
1937    } finally {
1938    if (jjtc000) {
1939      jjtree.closeNodeScope(jjtn000, true);
1940    }
1941    }
1942  }
1943
1944  final public void Literal() throws ParseException {
1945 /*@bgen(jjtree) Literal */
1946    SimpleNode jjtn000 = new SimpleNode(JJTLITERAL);
1947    boolean jjtc000 = true;
1948    jjtree.openNodeScope(jjtn000);Token tok = null;
1949    try {
1950      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1951      case INTEGER_LITERAL:
1952        tok = jj_consume_token(INTEGER_LITERAL);
1953        break;
1954      case FLOATING_POINT_LITERAL:
1955        tok = jj_consume_token(FLOATING_POINT_LITERAL);
1956        break;
1957      case CHARACTER_LITERAL:
1958        tok = jj_consume_token(CHARACTER_LITERAL);
1959        break;
1960      case STRING_LITERAL:
1961        tok = jj_consume_token(STRING_LITERAL);
1962        break;
1963      case FALSE:
1964      case TRUE:
1965        BooleanLiteral();
1966        break;
1967      case NULL:
1968        NullLiteral();
1969        break;
1970      default:
1971        jj_la1[48] = jj_gen;
1972        jj_consume_token(-1);
1973        throw new ParseException();
1974      }
1975    jjtree.closeNodeScope(jjtn000, true);
1976    jjtc000 = false;
1977    if (tok != null) jjtn000.setAttribute("token", tok);
1978    } catch (Throwable JavaDoc jjte000) {
1979    if (jjtc000) {
1980      jjtree.clearNodeScope(jjtn000);
1981      jjtc000 = false;
1982    } else {
1983      jjtree.popNode();
1984    }
1985    if (jjte000 instanceof RuntimeException JavaDoc) {
1986      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1987    }
1988    if (jjte000 instanceof ParseException) {
1989      {if (true) throw (ParseException)jjte000;}
1990    }
1991    {if (true) throw (Error JavaDoc)jjte000;}
1992    } finally {
1993    if (jjtc000) {
1994      jjtree.closeNodeScope(jjtn000, true);
1995    }
1996    }
1997  }
1998
1999  final public void BooleanLiteral() throws ParseException {
2000 /*@bgen(jjtree) BooleanLiteral */
2001    SimpleNode jjtn000 = new SimpleNode(JJTBOOLEANLITERAL);
2002    boolean jjtc000 = true;
2003    jjtree.openNodeScope(jjtn000);Token tok;
2004    try {
2005      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2006      case TRUE:
2007        tok = jj_consume_token(TRUE);
2008        break;
2009      case FALSE:
2010        tok = jj_consume_token(FALSE);
2011        break;
2012      default:
2013        jj_la1[49] = jj_gen;
2014        jj_consume_token(-1);
2015        throw new ParseException();
2016      }
2017    jjtree.closeNodeScope(jjtn000, true);
2018    jjtc000 = false;
2019    jjtn000.setAttribute("token", tok);
2020    } finally {
2021    if (jjtc000) {
2022      jjtree.closeNodeScope(jjtn000, true);
2023    }
2024    }
2025  }
2026
2027  final public void NullLiteral() throws ParseException {
2028                      /*@bgen(jjtree) NullLiteral */
2029  SimpleNode jjtn000 = new SimpleNode(JJTNULLLITERAL);
2030  boolean jjtc000 = true;
2031  jjtree.openNodeScope(jjtn000);
2032    try {
2033      jj_consume_token(NULL);
2034    jjtree.closeNodeScope(jjtn000, true);
2035    jjtc000 = false;
2036    jjtn000.setAttribute("token", token);
2037    } finally {
2038    if (jjtc000) {
2039      jjtree.closeNodeScope(jjtn000, true);
2040    }
2041    }
2042  }
2043
2044  final public void Arguments() throws ParseException {
2045                    /*@bgen(jjtree) Arguments */
2046  SimpleNode jjtn000 = new SimpleNode(JJTARGUMENTS);
2047  boolean jjtc000 = true;
2048  jjtree.openNodeScope(jjtn000);
2049    try {
2050      jj_consume_token(LPAREN);
2051      if (jj_2_12(1)) {
2052        ArgumentList();
2053      } else {
2054        ;
2055      }
2056      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2057      case COMMA:
2058        jj_consume_token(COMMA);
2059        break;
2060      default:
2061        jj_la1[50] = jj_gen;
2062        ;
2063      }
2064      jj_consume_token(RPAREN);
2065    } catch (Throwable JavaDoc jjte000) {
2066    if (jjtc000) {
2067      jjtree.clearNodeScope(jjtn000);
2068      jjtc000 = false;
2069    } else {
2070      jjtree.popNode();
2071    }
2072    if (jjte000 instanceof RuntimeException JavaDoc) {
2073      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2074    }
2075    if (jjte000 instanceof ParseException) {
2076      {if (true) throw (ParseException)jjte000;}
2077    }
2078    {if (true) throw (Error JavaDoc)jjte000;}
2079    } finally {
2080    if (jjtc000) {
2081      jjtree.closeNodeScope(jjtn000, true);
2082    }
2083    }
2084  }
2085
2086  final public void ArgumentList() throws ParseException {
2087                       /*@bgen(jjtree) ArgumentList */
2088  SimpleNode jjtn000 = new SimpleNode(JJTARGUMENTLIST);
2089  boolean jjtc000 = true;
2090  jjtree.openNodeScope(jjtn000);
2091    try {
2092      Expression();
2093      label_20:
2094      while (true) {
2095        if (expressionLookahead()) {
2096          ;
2097        } else {
2098          break label_20;
2099        }
2100        jj_consume_token(COMMA);
2101        Expression();
2102      }
2103    } catch (Throwable JavaDoc jjte000) {
2104    if (jjtc000) {
2105      jjtree.clearNodeScope(jjtn000);
2106      jjtc000 = false;
2107    } else {
2108      jjtree.popNode();
2109    }
2110    if (jjte000 instanceof RuntimeException JavaDoc) {
2111      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2112    }
2113    if (jjte000 instanceof ParseException) {
2114      {if (true) throw (ParseException)jjte000;}
2115    }
2116    {if (true) throw (Error JavaDoc)jjte000;}
2117    } finally {
2118    if (jjtc000) {
2119      jjtree.closeNodeScope(jjtn000, true);
2120    }
2121    }
2122  }
2123
2124  final public void AllocationExpression() throws ParseException {
2125                               /*@bgen(jjtree) AllocationExpression */
2126  SimpleNode jjtn000 = new SimpleNode(JJTALLOCATIONEXPRESSION);
2127  boolean jjtc000 = true;
2128  jjtree.openNodeScope(jjtn000);
2129    try {
2130      jj_consume_token(NEW);
2131      if (jj_2_13(2147483647)) {
2132        ClassOrInterfaceType();
2133        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2134        case LBRACKET:
2135          ArrayDimsAndInits();
2136          break;
2137        case LPAREN:
2138          Arguments();
2139          break;
2140        default:
2141          jj_la1[51] = jj_gen;
2142          jj_consume_token(-1);
2143          throw new ParseException();
2144        }
2145      } else {
2146        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2147        case BOOLEAN:
2148        case BYTE:
2149        case CHAR:
2150        case DOUBLE:
2151        case FLOAT:
2152        case INT:
2153        case LONG:
2154        case SHORT:
2155          PrimitiveType();
2156          ArrayDimsAndInits();
2157          break;
2158        default:
2159          jj_la1[52] = jj_gen;
2160          jj_consume_token(-1);
2161          throw new ParseException();
2162        }
2163      }
2164    } catch (Throwable JavaDoc jjte000) {
2165    if (jjtc000) {
2166      jjtree.clearNodeScope(jjtn000);
2167      jjtc000 = false;
2168    } else {
2169      jjtree.popNode();
2170    }
2171    if (jjte000 instanceof RuntimeException JavaDoc) {
2172      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2173    }
2174    if (jjte000 instanceof ParseException) {
2175      {if (true) throw (ParseException)jjte000;}
2176    }
2177    {if (true) throw (Error JavaDoc)jjte000;}
2178    } finally {
2179    if (jjtc000) {
2180      jjtree.closeNodeScope(jjtn000, true);
2181    }
2182    }
2183  }
2184
2185/*
2186 * The third LOOKAHEAD specification below is to parse to PrimarySuffix
2187 * if there is an expression between the "[...]".
2188 */

2189  final public void ArrayDimsAndInits() throws ParseException {
2190 /*@bgen(jjtree) ArrayDimsAndInits */
2191    SimpleNode jjtn000 = new SimpleNode(JJTARRAYDIMSANDINITS);
2192    boolean jjtc000 = true;
2193    jjtree.openNodeScope(jjtn000);int arrayCount = 0;
2194    try {
2195      if (jj_2_16(2)) {
2196        label_21:
2197        while (true) {
2198          jj_consume_token(LBRACKET);
2199          Expression();
2200          jj_consume_token(RBRACKET);
2201       arrayCount++;
2202          if (jj_2_14(2)) {
2203            ;
2204          } else {
2205            break label_21;
2206          }
2207        }
2208        label_22:
2209        while (true) {
2210          if (jj_2_15(4)) {
2211            ;
2212          } else {
2213            break label_22;
2214          }
2215          jj_consume_token(LBRACKET);
2216          jj_consume_token(RBRACKET);
2217       arrayCount++;
2218        }
2219      } else {
2220        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2221        case LBRACKET:
2222          label_23:
2223          while (true) {
2224            jj_consume_token(LBRACKET);
2225            jj_consume_token(RBRACKET);
2226       arrayCount++;
2227            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2228            case LBRACKET:
2229              ;
2230              break;
2231            default:
2232              jj_la1[53] = jj_gen;
2233              break label_23;
2234            }
2235          }
2236          ArrayInitializer();
2237      jjtn000.setAttribute("initializers", Boolean.TRUE);
2238          break;
2239        default:
2240          jj_la1[54] = jj_gen;
2241          jj_consume_token(-1);
2242          throw new ParseException();
2243        }
2244      }
2245    jjtree.closeNodeScope(jjtn000, true);
2246    jjtc000 = false;
2247    jjtn000.setAttribute("dimensions", new Integer JavaDoc(arrayCount));
2248    } catch (Throwable JavaDoc jjte000) {
2249    if (jjtc000) {
2250      jjtree.clearNodeScope(jjtn000);
2251      jjtc000 = false;
2252    } else {
2253      jjtree.popNode();
2254    }
2255    if (jjte000 instanceof RuntimeException JavaDoc) {
2256      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2257    }
2258    if (jjte000 instanceof ParseException) {
2259      {if (true) throw (ParseException)jjte000;}
2260    }
2261    {if (true) throw (Error JavaDoc)jjte000;}
2262    } finally {
2263    if (jjtc000) {
2264      jjtree.closeNodeScope(jjtn000, true);
2265    }
2266    }
2267  }
2268
2269  final private boolean jj_2_1(int xla) {
2270    jj_la = xla; jj_lastpos = jj_scanpos = token;
2271    try { return !jj_3_1(); }
2272    catch(LookaheadSuccess ls) { return true; }
2273    finally { jj_save(0, xla); }
2274  }
2275
2276  final private boolean jj_2_2(int xla) {
2277    jj_la = xla; jj_lastpos = jj_scanpos = token;
2278    try { return !jj_3_2(); }
2279    catch(LookaheadSuccess ls) { return true; }
2280    finally { jj_save(1, xla); }
2281  }
2282
2283  final private boolean jj_2_3(int xla) {
2284    jj_la = xla; jj_lastpos = jj_scanpos = token;
2285    try { return !jj_3_3(); }
2286    catch(LookaheadSuccess ls) { return true; }
2287    finally { jj_save(2, xla); }
2288  }
2289
2290  final private boolean jj_2_4(int xla) {
2291    jj_la = xla; jj_lastpos = jj_scanpos = token;
2292    try { return !jj_3_4(); }
2293    catch(LookaheadSuccess ls) { return true; }
2294    finally { jj_save(3, xla); }
2295  }
2296
2297  final private boolean jj_2_5(int xla) {
2298    jj_la = xla; jj_lastpos = jj_scanpos = token;
2299    try { return !jj_3_5(); }
2300    catch(LookaheadSuccess ls) { return true; }
2301    finally { jj_save(4, xla); }
2302  }
2303
2304  final private boolean jj_2_6(int xla) {
2305    jj_la = xla; jj_lastpos = jj_scanpos = token;
2306    try { return !jj_3_6(); }
2307    catch(LookaheadSuccess ls) { return true; }
2308    finally { jj_save(5, xla); }
2309  }
2310
2311  final private boolean jj_2_7(int xla) {
2312    jj_la = xla; jj_lastpos = jj_scanpos = token;
2313    try { return !jj_3_7(); }
2314    catch(LookaheadSuccess ls) { return true; }
2315    finally { jj_save(6, xla); }
2316  }
2317
2318  final private boolean jj_2_8(int xla) {
2319    jj_la = xla; jj_lastpos = jj_scanpos = token;
2320    try { return !jj_3_8(); }
2321    catch(LookaheadSuccess ls) { return true; }
2322    finally { jj_save(7, xla); }
2323  }
2324
2325  final private boolean jj_2_9(int xla) {
2326    jj_la = xla; jj_lastpos = jj_scanpos = token;
2327    try { return !jj_3_9(); }
2328    catch(LookaheadSuccess ls) { return true; }
2329    finally { jj_save(8, xla); }
2330  }
2331
2332  final private boolean jj_2_10(int xla) {
2333    jj_la = xla; jj_lastpos = jj_scanpos = token;
2334    try { return !jj_3_10(); }
2335    catch(LookaheadSuccess ls) { return true; }
2336    finally { jj_save(9, xla); }
2337  }
2338
2339  final private boolean jj_2_11(int xla) {
2340    jj_la = xla; jj_lastpos = jj_scanpos = token;
2341    try { return !jj_3_11(); }
2342    catch(LookaheadSuccess ls) { return true; }
2343    finally { jj_save(10, xla); }
2344  }
2345
2346  final private boolean jj_2_12(int xla) {
2347    jj_la = xla; jj_lastpos = jj_scanpos = token;
2348    try { return !jj_3_12(); }
2349    catch(LookaheadSuccess ls) { return true; }
2350    finally { jj_save(11, xla); }
2351  }
2352
2353  final private boolean jj_2_13(int xla) {
2354    jj_la = xla; jj_lastpos = jj_scanpos = token;
2355    try { return !jj_3_13(); }
2356    catch(LookaheadSuccess ls) { return true; }
2357    finally { jj_save(12, xla); }
2358  }
2359
2360  final private boolean jj_2_14(int xla) {
2361    jj_la = xla; jj_lastpos = jj_scanpos = token;
2362    try { return !jj_3_14(); }
2363    catch(LookaheadSuccess ls) { return true; }
2364    finally { jj_save(13, xla); }
2365  }
2366
2367  final private boolean jj_2_15(int xla) {
2368    jj_la = xla; jj_lastpos = jj_scanpos = token;
2369    try { return !jj_3_15(); }
2370    catch(LookaheadSuccess ls) { return true; }
2371    finally { jj_save(14, xla); }
2372  }
2373
2374  final private boolean jj_2_16(int xla) {
2375    jj_la = xla; jj_lastpos = jj_scanpos = token;
2376    try { return !jj_3_16(); }
2377    catch(LookaheadSuccess ls) { return true; }
2378    finally { jj_save(15, xla); }
2379  }
2380
2381  final private boolean jj_3_3() {
2382    if (jj_3R_25()) return true;
2383    return false;
2384  }
2385
2386  final private boolean jj_3R_100() {
2387    if (jj_3R_101()) return true;
2388    return false;
2389  }
2390
2391  final private boolean jj_3R_93() {
2392    if (jj_3R_96()) return true;
2393    return false;
2394  }
2395
2396  final private boolean jj_3R_92() {
2397    if (jj_3R_95()) return true;
2398    return false;
2399  }
2400
2401  final private boolean jj_3R_33() {
2402    if (jj_scan_token(DOT)) return true;
2403    Token xsp;
2404    xsp = jj_scanpos;
2405    if (jj_3R_48()) jj_scanpos = xsp;
2406    if (jj_scan_token(IDENTIFIER)) return true;
2407    return false;
2408  }
2409
2410  final private boolean jj_3R_56() {
2411    if (jj_scan_token(LBRACE)) return true;
2412    return false;
2413  }
2414
2415  final private boolean jj_3R_87() {
2416    Token xsp;
2417    xsp = jj_scanpos;
2418    if (jj_scan_token(71)) {
2419    jj_scanpos = xsp;
2420    if (jj_scan_token(75)) {
2421    jj_scanpos = xsp;
2422    if (jj_scan_token(77)) {
2423    jj_scanpos = xsp;
2424    if (jj_scan_token(78)) {
2425    jj_scanpos = xsp;
2426    if (jj_3R_92()) {
2427    jj_scanpos = xsp;
2428    if (jj_3R_93()) return true;
2429    }
2430    }
2431    }
2432    }
2433    }
2434    return false;
2435  }
2436
2437  final private boolean jj_3_1() {
2438    if (jj_3R_24()) return true;
2439    return false;
2440  }
2441
2442  final private boolean jj_3R_40() {
2443    if (jj_3R_56()) return true;
2444    return false;
2445  }
2446
2447  final private boolean jj_3R_25() {
2448    Token xsp;
2449    xsp = jj_scanpos;
2450    if (jj_3R_40()) {
2451    jj_scanpos = xsp;
2452    if (jj_3_1()) return true;
2453    }
2454    return false;
2455  }
2456
2457  final private boolean jj_3R_24() {
2458    if (jj_3R_39()) return true;
2459    return false;
2460  }
2461
2462  final private boolean jj_3R_52() {
2463    if (jj_scan_token(IDENTIFIER)) return true;
2464    return false;
2465  }
2466
2467  final private boolean jj_3R_32() {
2468    if (jj_scan_token(DOT)) return true;
2469    if (jj_scan_token(LT)) return true;
2470    return false;
2471  }
2472
2473  final private boolean jj_3R_99() {
2474    if (jj_3R_100()) return true;
2475    return false;
2476  }
2477
2478  final private boolean jj_3_7() {
2479    if (jj_scan_token(DOT)) return true;
2480    if (jj_scan_token(IDENTIFIER)) return true;
2481    return false;
2482  }
2483
2484  final private boolean jj_3R_85() {
2485    if (jj_scan_token(SUPER)) return true;
2486    return false;
2487  }
2488
2489  final private boolean jj_3R_44() {
2490    if (jj_3R_26()) return true;
2491    return false;
2492  }
2493
2494  final private boolean jj_3R_84() {
2495    if (jj_scan_token(EXTENDS)) return true;
2496    return false;
2497  }
2498
2499  final private boolean jj_3R_67() {
2500    if (jj_3R_66()) return true;
2501    return false;
2502  }
2503
2504  final private boolean jj_3R_75() {
2505    Token xsp;
2506    xsp = jj_scanpos;
2507    if (jj_3R_84()) {
2508    jj_scanpos = xsp;
2509    if (jj_3R_85()) return true;
2510    }
2511    if (jj_3R_26()) return true;
2512    return false;
2513  }
2514
2515  final private boolean jj_3R_54() {
2516    if (jj_scan_token(DOT)) return true;
2517    if (jj_3R_52()) return true;
2518    Token xsp;
2519    xsp = jj_scanpos;
2520    if (jj_3R_67()) jj_scanpos = xsp;
2521    return false;
2522  }
2523
2524  final private boolean jj_3R_53() {
2525    if (jj_3R_66()) return true;
2526    return false;
2527  }
2528
2529  final private boolean jj_3R_43() {
2530    if (jj_scan_token(HOOK)) return true;
2531    Token xsp;
2532    xsp = jj_scanpos;
2533    if (jj_3R_75()) jj_scanpos = xsp;
2534    return false;
2535  }
2536
2537  final private boolean jj_3R_38() {
2538    if (jj_3R_52()) return true;
2539    Token xsp;
2540    xsp = jj_scanpos;
2541    if (jj_3R_53()) jj_scanpos = xsp;
2542    while (true) {
2543      xsp = jj_scanpos;
2544      if (jj_3R_54()) { jj_scanpos = xsp; break; }
2545    }
2546    return false;
2547  }
2548
2549  final private boolean jj_3_11() {
2550    if (jj_3R_36()) return true;
2551    if (jj_scan_token(DOT)) return true;
2552    if (jj_scan_token(CLASS)) return true;
2553    return false;
2554  }
2555
2556  final private boolean jj_3R_27() {
2557    Token xsp;
2558    xsp = jj_scanpos;
2559    if (jj_3R_43()) {
2560    jj_scanpos = xsp;
2561    if (jj_3R_44()) return true;
2562    }
2563    return false;
2564  }
2565
2566  final private boolean jj_3R_98() {
2567    if (jj_3R_99()) return true;
2568    return false;
2569  }
2570
2571  final private boolean jj_3R_31() {
2572    if (jj_scan_token(DOT)) return true;
2573    if (jj_scan_token(NEW)) return true;
2574    return false;
2575  }
2576
2577  final private boolean jj_3R_83() {
2578    if (jj_3R_90()) return true;
2579    return false;
2580  }
2581
2582  final private boolean jj_3_6() {
2583    if (jj_scan_token(DOT)) return true;
2584    if (jj_scan_token(IDENTIFIER)) return true;
2585    return false;
2586  }
2587
2588  final private boolean jj_3R_82() {
2589    if (jj_3R_36()) return true;
2590    return false;
2591  }
2592
2593  final private boolean jj_3R_81() {
2594    if (jj_3R_89()) return true;
2595    return false;
2596  }
2597
2598  final private boolean jj_3R_64() {
2599    if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
2600    return false;
2601  }
2602
2603  final private boolean jj_3R_90() {
2604    if (jj_scan_token(IDENTIFIER)) return true;
2605    return false;
2606  }
2607
2608  final private boolean jj_3R_80() {
2609    if (jj_scan_token(LPAREN)) return true;
2610    return false;
2611  }
2612
2613  final private boolean jj_3R_63() {
2614    if (jj_scan_token(RSIGNEDSHIFT)) return true;
2615    return false;
2616  }
2617
2618  final private boolean jj_3R_35() {
2619    if (jj_scan_token(IDENTIFIER)) return true;
2620    if (jj_scan_token(DOT)) return true;
2621    return false;
2622  }
2623
2624  final private boolean jj_3R_30() {
2625    if (jj_scan_token(DOT)) return true;
2626    if (jj_scan_token(SUPER)) return true;
2627    return false;
2628  }
2629
2630  final private boolean jj_3_10() {
2631    Token xsp;
2632    while (true) {
2633      xsp = jj_scanpos;
2634      if (jj_3R_35()) { jj_scanpos = xsp; break; }
2635    }
2636    if (jj_scan_token(SUPER)) return true;
2637    if (jj_scan_token(DOT)) return true;
2638    return false;
2639  }
2640
2641  final private boolean jj_3R_97() {
2642    if (jj_3R_98()) return true;
2643    return false;
2644  }
2645
2646  final private boolean jj_3R_88() {
2647    if (jj_scan_token(IDENTIFIER)) return true;
2648    return false;
2649  }
2650
2651  final private boolean jj_3R_62() {
2652    if (jj_scan_token(COMMA)) return true;
2653    if (jj_3R_27()) return true;
2654    return false;
2655  }
2656
2657  final private boolean jj_3R_51() {
2658    if (jj_3R_65()) return true;
2659    return false;
2660  }
2661
2662  final private boolean jj_3R_79() {
2663    Token xsp;
2664    while (true) {
2665      xsp = jj_scanpos;
2666      if (jj_3R_88()) { jj_scanpos = xsp; break; }
2667    }
2668    if (jj_scan_token(SUPER)) return true;
2669    return false;
2670  }
2671
2672  final private boolean jj_3R_36() {
2673    Token xsp;
2674    xsp = jj_scanpos;
2675    if (jj_3R_50()) {
2676    jj_scanpos = xsp;
2677    if (jj_3R_51()) return true;
2678    }
2679    return false;
2680  }
2681
2682  final private boolean jj_3R_50() {
2683    if (jj_scan_token(VOID)) return true;
2684    return false;
2685  }
2686
2687  final private boolean jj_3R_78() {
2688    if (jj_scan_token(THIS)) return true;
2689    return false;
2690  }
2691
2692  final private boolean jj_3R_29() {
2693    if (jj_scan_token(DOT)) return true;
2694    if (jj_scan_token(THIS)) return true;
2695    return false;
2696  }
2697
2698  final private boolean jj_3_9() {
2699    Token xsp;
2700    xsp = jj_scanpos;
2701    if (jj_3R_29()) {
2702    jj_scanpos = xsp;
2703    if (jj_3R_30()) {
2704    jj_scanpos = xsp;
2705    if (jj_3R_31()) {
2706    jj_scanpos = xsp;
2707    if (jj_scan_token(82)) {
2708    jj_scanpos = xsp;
2709    if (jj_scan_token(86)) {
2710    jj_scanpos = xsp;
2711    if (jj_3R_32()) {
2712    jj_scanpos = xsp;
2713    if (jj_3R_33()) {
2714    jj_scanpos = xsp;
2715    if (jj_3R_34()) return true;
2716    }
2717    }
2718    }
2719    }
2720    }
2721    }
2722    }
2723    return false;
2724  }
2725
2726  final private boolean jj_3R_77() {
2727    if (jj_3R_87()) return true;
2728    return false;
2729  }
2730
2731  final private boolean jj_3R_49() {
2732    if (jj_scan_token(LT)) return true;
2733    if (jj_3R_27()) return true;
2734    Token xsp;
2735    while (true) {
2736      xsp = jj_scanpos;
2737      if (jj_3R_62()) { jj_scanpos = xsp; break; }
2738    }
2739    xsp = jj_scanpos;
2740    if (jj_scan_token(93)) {
2741    jj_scanpos = xsp;
2742    if (jj_3R_63()) {
2743    jj_scanpos = xsp;
2744    if (jj_3R_64()) return true;
2745    }
2746    }
2747    return false;
2748  }
2749
2750  final private boolean jj_3R_94() {
2751    if (jj_3R_97()) return true;
2752    return false;
2753  }
2754
2755  final private boolean jj_3R_74() {
2756    Token xsp;
2757    xsp = jj_scanpos;
2758    if (jj_3R_77()) {
2759    jj_scanpos = xsp;
2760    if (jj_3R_78()) {
2761    jj_scanpos = xsp;
2762    if (jj_3R_79()) {
2763    jj_scanpos = xsp;
2764    if (jj_3R_80()) {
2765    jj_scanpos = xsp;
2766    if (jj_3R_81()) {
2767    jj_scanpos = xsp;
2768    if (jj_3R_82()) {
2769    jj_scanpos = xsp;
2770    if (jj_3R_83()) return true;
2771    }
2772    }
2773    }
2774    }
2775    }
2776    }
2777    return false;
2778  }
2779
2780  final private boolean jj_3R_91() {
2781    if (jj_3R_94()) return true;
2782    return false;
2783  }
2784
2785  final private boolean jj_3R_69() {
2786    if (jj_3R_74()) return true;
2787    return false;
2788  }
2789
2790  final private boolean jj_3R_58() {
2791    Token xsp;
2792    xsp = jj_scanpos;
2793    if (jj_scan_token(20)) {
2794    jj_scanpos = xsp;
2795    if (jj_scan_token(25)) {
2796    jj_scanpos = xsp;
2797    if (jj_scan_token(22)) {
2798    jj_scanpos = xsp;
2799    if (jj_scan_token(56)) {
2800    jj_scanpos = xsp;
2801    if (jj_scan_token(45)) {
2802    jj_scanpos = xsp;
2803    if (jj_scan_token(47)) {
2804    jj_scanpos = xsp;
2805    if (jj_scan_token(38)) {
2806    jj_scanpos = xsp;
2807    if (jj_scan_token(31)) return true;
2808    }
2809    }
2810    }
2811    }
2812    }
2813    }
2814    }
2815    return false;
2816  }
2817
2818  final private boolean jj_3R_60() {
2819    if (jj_scan_token(LPAREN)) return true;
2820    return false;
2821  }
2822
2823  final private boolean jj_3R_86() {
2824    if (jj_3R_91()) return true;
2825    return false;
2826  }
2827
2828  final private boolean jj_3R_72() {
2829    if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
2830    return false;
2831  }
2832
2833  final private boolean jj_3R_61() {
2834    if (jj_3R_69()) return true;
2835    return false;
2836  }
2837
2838  final private boolean jj_3R_71() {
2839    if (jj_scan_token(RSIGNEDSHIFT)) return true;
2840    return false;
2841  }
2842
2843  final private boolean jj_3_15() {
2844    if (jj_scan_token(LBRACKET)) return true;
2845    if (jj_scan_token(RBRACKET)) return true;
2846    return false;
2847  }
2848
2849  final private boolean jj_3R_76() {
2850    if (jj_3R_86()) return true;
2851    return false;
2852  }
2853
2854  final private boolean jj_3R_47() {
2855    if (jj_3R_61()) return true;
2856    return false;
2857  }
2858
2859  final private boolean jj_3_14() {
2860    if (jj_scan_token(LBRACKET)) return true;
2861    if (jj_3R_24()) return true;
2862    return false;
2863  }
2864
2865  final private boolean jj_3_5() {
2866    if (jj_scan_token(COMMA)) return true;
2867    if (jj_3R_27()) return true;
2868    return false;
2869  }
2870
2871  final private boolean jj_3_16() {
2872    Token xsp;
2873    if (jj_3_14()) return true;
2874    while (true) {
2875      xsp = jj_scanpos;
2876      if (jj_3_14()) { jj_scanpos = xsp; break; }
2877    }
2878    return false;
2879  }
2880
2881  final private boolean jj_3R_46() {
2882    Token xsp;
2883    xsp = jj_scanpos;
2884    if (jj_scan_token(96)) {
2885    jj_scanpos = xsp;
2886    if (jj_scan_token(95)) return true;
2887    }
2888    return false;
2889  }
2890
2891  final private boolean jj_3R_45() {
2892    if (jj_3R_60()) return true;
2893    return false;
2894  }
2895
2896  final private boolean jj_3R_73() {
2897    if (jj_3R_76()) return true;
2898    return false;
2899  }
2900
2901  final private boolean jj_3R_66() {
2902    if (jj_scan_token(LT)) return true;
2903    if (jj_3R_27()) return true;
2904    Token xsp;
2905    while (true) {
2906      xsp = jj_scanpos;
2907      if (jj_3_5()) { jj_scanpos = xsp; break; }
2908    }
2909    xsp = jj_scanpos;
2910    if (jj_scan_token(93)) {
2911    jj_scanpos = xsp;
2912    if (jj_3R_71()) {
2913    jj_scanpos = xsp;
2914    if (jj_3R_72()) return true;
2915    }
2916    }
2917    return false;
2918  }
2919
2920  final private boolean jj_3R_28() {
2921    Token xsp;
2922    xsp = jj_scanpos;
2923    lookingAhead = true;
2924    jj_semLA = castLookahead();
2925    lookingAhead = false;
2926    if (!jj_semLA || jj_3R_45()) {
2927    jj_scanpos = xsp;
2928    if (jj_3R_46()) {
2929    jj_scanpos = xsp;
2930    if (jj_3R_47()) return true;
2931    }
2932    }
2933    return false;
2934  }
2935
2936  final private boolean jj_3R_106() {
2937    if (jj_scan_token(DECR)) return true;
2938    return false;
2939  }
2940
2941  final private boolean jj_3_13() {
2942    if (jj_3R_38()) return true;
2943    return false;
2944  }
2945
2946  final private boolean jj_3R_59() {
2947    if (jj_scan_token(LBRACKET)) return true;
2948    if (jj_scan_token(RBRACKET)) return true;
2949    return false;
2950  }
2951
2952  final private boolean jj_3R_68() {
2953    if (jj_3R_73()) return true;
2954    return false;
2955  }
2956
2957  final private boolean jj_3R_105() {
2958    if (jj_scan_token(INCR)) return true;
2959    return false;
2960  }
2961
2962  final private boolean jj_3R_42() {
2963    if (jj_3R_58()) return true;
2964    Token xsp;
2965    if (jj_3R_59()) return true;
2966    while (true) {
2967      xsp = jj_scanpos;
2968      if (jj_3R_59()) { jj_scanpos = xsp; break; }
2969    }
2970    return false;
2971  }
2972
2973  final private boolean jj_3R_57() {
2974    if (jj_scan_token(LBRACKET)) return true;
2975    if (jj_scan_token(RBRACKET)) return true;
2976    return false;
2977  }
2978
2979  final private boolean jj_3R_34() {
2980    if (jj_3R_49()) return true;
2981    return false;
2982  }
2983
2984  final private boolean jj_3R_89() {
2985    if (jj_scan_token(NEW)) return true;
2986    return false;
2987  }
2988
2989  final private boolean jj_3_8() {
2990    if (jj_3R_28()) return true;
2991    return false;
2992  }
2993
2994  final private boolean jj_3R_41() {
2995    if (jj_3R_38()) return true;
2996    Token xsp;
2997    while (true) {
2998      xsp = jj_scanpos;
2999      if (jj_3R_57()) { jj_scanpos = xsp; break; }
3000    }
3001    return false;
3002  }
3003
3004  final private boolean jj_3R_26() {
3005    Token xsp;
3006    xsp = jj_scanpos;
3007    if (jj_3R_41()) {
3008    jj_scanpos = xsp;
3009    if (jj_3R_42()) return true;
3010    }
3011    return false;
3012  }
3013
3014  final private boolean jj_3R_55() {
3015    if (jj_3R_68()) return true;
3016    return false;
3017  }
3018
3019  final private boolean jj_3R_104() {
3020    if (jj_3R_106()) return true;
3021    return false;
3022  }
3023
3024  final private boolean jj_3R_103() {
3025    if (jj_3R_105()) return true;
3026    return false;
3027  }
3028
3029  final private boolean jj_3R_37() {
3030    if (jj_3R_24()) return true;
3031    return false;
3032  }
3033
3034  final private boolean jj_3R_70() {
3035    if (jj_3R_58()) return true;
3036    return false;
3037  }
3038
3039  final private boolean jj_3_12() {
3040    if (jj_3R_37()) return true;
3041    return false;
3042  }
3043
3044  final private boolean jj_3R_102() {
3045    Token xsp;
3046    xsp = jj_scanpos;
3047    if (jj_scan_token(107)) {
3048    jj_scanpos = xsp;
3049    if (jj_scan_token(108)) return true;
3050    }
3051    return false;
3052  }
3053
3054  final private boolean jj_3_4() {
3055    if (jj_3R_26()) return true;
3056    return false;
3057  }
3058
3059  final private boolean jj_3R_101() {
3060    Token xsp;
3061    xsp = jj_scanpos;
3062    if (jj_3R_102()) {
3063    jj_scanpos = xsp;
3064    if (jj_3R_103()) {
3065    jj_scanpos = xsp;
3066    if (jj_3R_104()) {
3067    jj_scanpos = xsp;
3068    if (jj_3_8()) return true;
3069    }
3070    }
3071    }
3072    return false;
3073  }
3074
3075  final private boolean jj_3R_65() {
3076    Token xsp;
3077    xsp = jj_scanpos;
3078    if (jj_3_4()) {
3079    jj_scanpos = xsp;
3080    if (jj_3R_70()) return true;
3081    }
3082    return false;
3083  }
3084
3085  final private boolean jj_3R_39() {
3086    if (jj_3R_55()) return true;
3087    return false;
3088  }
3089
3090  final private boolean jj_3R_96() {
3091    if (jj_scan_token(NULL)) return true;
3092    return false;
3093  }
3094
3095  final private boolean jj_3R_95() {
3096    Token xsp;
3097    xsp = jj_scanpos;
3098    if (jj_scan_token(66)) {
3099    jj_scanpos = xsp;
3100    if (jj_scan_token(35)) return true;
3101    }
3102    return false;
3103  }
3104
3105  final private boolean jj_3_2() {
3106    if (jj_scan_token(COMMA)) return true;
3107    if (jj_3R_25()) return true;
3108    return false;
3109  }
3110
3111  final private boolean jj_3R_48() {
3112    if (jj_3R_49()) return true;
3113    return false;
3114  }
3115
3116  public JavaParserTokenManager token_source;
3117  SimpleCharStream jj_input_stream;
3118  public Token token, jj_nt;
3119  private int jj_ntk;
3120  private Token jj_scanpos, jj_lastpos;
3121  private int jj_la;
3122  public boolean lookingAhead = false;
3123  private boolean jj_semLA;
3124  private int jj_gen;
3125  final private int[] jj_la1 = new int[55];
3126  static private int[] jj_la1_0;
3127  static private int[] jj_la1_1;
3128  static private int[] jj_la1_2;
3129  static private int[] jj_la1_3;
3130  static private int[] jj_la1_4;
3131  static {
3132      jj_la1_0();
3133      jj_la1_1();
3134      jj_la1_2();
3135      jj_la1_3();
3136      jj_la1_4();
3137   }
3138   private static void jj_la1_0() {
3139      jj_la1_0 = new int[] {0x0,0x0,0x0,0x0,0x82500000,0x0,0x0,0x82500000,0x0,0x0,0x82500000,0x0,0x82500000,0x82500000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x82500000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x82500000,0x0,0x0,};
3140   }
3141   private static void jj_la1_1() {
3142      jj_la1_1 = new int[] {0x0,0x0,0x8000004,0x8000004,0x100a040,0x0,0x0,0x100a040,0x0,0x0,0x100a040,0x0,0x100a040,0x100a040,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4906a048,0x0,0x0,0x0,0x40040008,0x20000,0x0,0x0,0x48020000,0x0,0x40008,0x8,0x0,0x0,0x100a040,0x0,0x0,};
3143   }
3144   private static void jj_la1_2() {
3145      jj_la1_2 = new int[] {0x2000000,0x20000000,0x0,0x0,0x8000,0x100000,0x2000000,0x0,0x400000,0x400000,0x8000,0x20000000,0x0,0x8010,0x40000000,0x40000000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60000000,0x60000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x8004e894,0x0,0x0,0x8000,0x6884,0x40000,0x8000,0x40000000,0x40008000,0x44440000,0x6884,0x4,0x2000000,0x440000,0x0,0x400000,0x400000,};
3146   }
3147   private static void jj_la1_3() {
3148      jj_la1_3 = new int[] {0x0,0x300000,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x300000,0x0,0x0,0x0,0x0,0xffc00000,0xffc00000,0x2,0x80,0x100,0x10000,0x20000,0x8000,0x48,0x48,0x0,0x30,0x30,0x380000,0x380000,0x1800,0x1800,0x46000,0x46000,0x1800,0x1e00,0x1,0x1,0x600,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
3149   }
3150   private static void jj_la1_4() {
3151      jj_la1_4 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
3152   }
3153  final private JJCalls[] jj_2_rtns = new JJCalls[16];
3154  private boolean jj_rescan = false;
3155  private int jj_gc = 0;
3156
3157  public JavaParser(java.io.InputStream JavaDoc stream) {
3158    jj_input_stream = new SimpleCharStream(stream, 1, 1);
3159    token_source = new JavaParserTokenManager(jj_input_stream);
3160    token = new Token();
3161    jj_ntk = -1;
3162    jj_gen = 0;
3163    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3164    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3165  }
3166
3167  public void ReInit(java.io.InputStream JavaDoc stream) {
3168    jj_input_stream.ReInit(stream, 1, 1);
3169    token_source.ReInit(jj_input_stream);
3170    token = new Token();
3171    jj_ntk = -1;
3172    jjtree.reset();
3173    jj_gen = 0;
3174    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3175    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3176  }
3177
3178  public JavaParser(java.io.Reader JavaDoc stream) {
3179    jj_input_stream = new SimpleCharStream(stream, 1, 1);
3180    token_source = new JavaParserTokenManager(jj_input_stream);
3181    token = new Token();
3182    jj_ntk = -1;
3183    jj_gen = 0;
3184    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3185    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3186  }
3187
3188  public void ReInit(java.io.Reader JavaDoc stream) {
3189    jj_input_stream.ReInit(stream, 1, 1);
3190    token_source.ReInit(jj_input_stream);
3191    token = new Token();
3192    jj_ntk = -1;
3193    jjtree.reset();
3194    jj_gen = 0;
3195    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3196    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3197  }
3198
3199  public JavaParser(JavaParserTokenManager tm) {
3200    token_source = tm;
3201    token = new Token();
3202    jj_ntk = -1;
3203    jj_gen = 0;
3204    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3205    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3206  }
3207
3208  public void ReInit(JavaParserTokenManager tm) {
3209    token_source = tm;
3210    token = new Token();
3211    jj_ntk = -1;
3212    jjtree.reset();
3213    jj_gen = 0;
3214    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
3215    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3216  }
3217
3218  final private Token jj_consume_token(int kind) throws ParseException {
3219    Token oldToken;
3220    if ((oldToken = token).next != null) token = token.next;
3221    else token = token.next = token_source.getNextToken();
3222    jj_ntk = -1;
3223    if (token.kind == kind) {
3224      jj_gen++;
3225      if (++jj_gc > 100) {
3226        jj_gc = 0;
3227        for (int i = 0; i < jj_2_rtns.length; i++) {
3228          JJCalls c = jj_2_rtns[i];
3229          while (c != null) {
3230            if (c.gen < jj_gen) c.first = null;
3231            c = c.next;
3232          }
3233        }
3234      }
3235      return token;
3236    }
3237    token = oldToken;
3238    jj_kind = kind;
3239    throw generateParseException();
3240  }
3241
3242  static private final class LookaheadSuccess extends java.lang.Error JavaDoc { }
3243  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3244  final private boolean jj_scan_token(int kind) {
3245    if (jj_scanpos == jj_lastpos) {
3246      jj_la--;
3247      if (jj_scanpos.next == null) {
3248        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
3249      } else {
3250        jj_lastpos = jj_scanpos = jj_scanpos.next;
3251      }
3252    } else {
3253      jj_scanpos = jj_scanpos.next;
3254    }
3255    if (jj_rescan) {
3256      int i = 0; Token tok = token;
3257      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
3258      if (tok != null) jj_add_error_token(kind, i);
3259    }
3260    if (jj_scanpos.kind != kind) return true;
3261    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
3262    return false;
3263  }
3264
3265  final public Token getNextToken() {
3266    if (token.next != null) token = token.next;
3267    else token = token.next = token_source.getNextToken();
3268    jj_ntk = -1;
3269    jj_gen++;
3270    return token;
3271  }
3272
3273  final public Token getToken(int index) {
3274    Token t = lookingAhead ? jj_scanpos : token;
3275    for (int i = 0; i < index; i++) {
3276      if (t.next != null) t = t.next;
3277      else t = t.next = token_source.getNextToken();
3278    }
3279    return t;
3280  }
3281
3282  final private int jj_ntk() {
3283    if ((jj_nt=token.next) == null)
3284      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
3285    else
3286      return (jj_ntk = jj_nt.kind);
3287  }
3288
3289  private java.util.Vector JavaDoc<int[]> jj_expentries = new java.util.Vector JavaDoc<int[]>();
3290  private int[] jj_expentry;
3291  private int jj_kind = -1;
3292  private int[] jj_lasttokens = new int[100];
3293  private int jj_endpos;
3294
3295  private void jj_add_error_token(int kind, int pos) {
3296    if (pos >= 100) return;
3297    if (pos == jj_endpos + 1) {
3298      jj_lasttokens[jj_endpos++] = kind;
3299    } else if (jj_endpos != 0) {
3300      jj_expentry = new int[jj_endpos];
3301      for (int i = 0; i < jj_endpos; i++) {
3302        jj_expentry[i] = jj_lasttokens[i];
3303      }
3304      boolean exists = false;
3305      for (java.util.Enumeration JavaDoc<int[]> e = jj_expentries.elements(); e.hasMoreElements();) {
3306        int[] oldentry = e.nextElement();
3307        if (oldentry.length == jj_expentry.length) {
3308          exists = true;
3309          for (int i = 0; i < jj_expentry.length; i++) {
3310            if (oldentry[i] != jj_expentry[i]) {
3311              exists = false;
3312              break;
3313            }
3314          }
3315          if (exists) break;
3316        }
3317      }
3318      if (!exists) jj_expentries.addElement(jj_expentry);
3319      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3320    }
3321  }
3322
3323  public ParseException generateParseException() {
3324    jj_expentries.removeAllElements();
3325    boolean[] la1tokens = new boolean[130];
3326    for (int i = 0; i < 130; i++) {
3327      la1tokens[i] = false;
3328    }
3329    if (jj_kind >= 0) {
3330      la1tokens[jj_kind] = true;
3331      jj_kind = -1;
3332    }
3333    for (int i = 0; i < 55; i++) {
3334      if (jj_la1[i] == jj_gen) {
3335        for (int j = 0; j < 32; j++) {
3336          if ((jj_la1_0[i] & (1<<j)) != 0) {
3337            la1tokens[j] = true;
3338          }
3339          if ((jj_la1_1[i] & (1<<j)) != 0) {
3340            la1tokens[32+j] = true;
3341          }
3342          if ((jj_la1_2[i] & (1<<j)) != 0) {
3343            la1tokens[64+j] = true;
3344          }
3345          if ((jj_la1_3[i] & (1<<j)) != 0) {
3346            la1tokens[96+j] = true;
3347          }
3348          if ((jj_la1_4[i] & (1<<j)) != 0) {
3349            la1tokens[128+j] = true;
3350          }
3351        }
3352      }
3353    }
3354    for (int i = 0; i < 130; i++) {
3355      if (la1tokens[i]) {
3356        jj_expentry = new int[1];
3357        jj_expentry[0] = i;
3358        jj_expentries.addElement(jj_expentry);
3359      }
3360    }
3361    jj_endpos = 0;
3362    jj_rescan_token();
3363    jj_add_error_token(0, 0);
3364    int[][] exptokseq = new int[jj_expentries.size()][];
3365    for (int i = 0; i < jj_expentries.size(); i++) {
3366      exptokseq[i] = jj_expentries.elementAt(i);
3367    }
3368    return new ParseException(token, exptokseq, tokenImage);
3369  }
3370
3371  final public void enable_tracing() {
3372  }
3373
3374  final public void disable_tracing() {
3375  }
3376
3377  final private void jj_rescan_token() {
3378    jj_rescan = true;
3379    for (int i = 0; i < 16; i++) {
3380      JJCalls p = jj_2_rtns[i];
3381      do {
3382        if (p.gen > jj_gen) {
3383          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
3384          switch (i) {
3385            case 0: jj_3_1(); break;
3386            case 1: jj_3_2(); break;
3387            case 2: jj_3_3(); break;
3388            case 3: jj_3_4(); break;
3389            case 4: jj_3_5(); break;
3390            case 5: jj_3_6(); break;
3391            case 6: jj_3_7(); break;
3392            case 7: jj_3_8(); break;
3393            case 8: jj_3_9(); break;
3394            case 9: jj_3_10(); break;
3395            case 10: jj_3_11(); break;
3396            case 11: jj_3_12(); break;
3397            case 12: jj_3_13(); break;
3398            case 13: jj_3_14(); break;
3399            case 14: jj_3_15(); break;
3400            case 15: jj_3_16(); break;
3401          }
3402        }
3403        p = p.next;
3404      } while (p != null);
3405    }
3406    jj_rescan = false;
3407  }
3408
3409  final private void jj_save(int index, int xla) {
3410    JJCalls p = jj_2_rtns[index];
3411    while (p.gen > jj_gen) {
3412      if (p.next == null) { p = p.next = new JJCalls(); break; }
3413      p = p.next;
3414    }
3415    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
3416  }
3417
3418  static final class JJCalls {
3419    int gen;
3420    Token first;
3421    int arg;
3422    JJCalls next;
3423  }
3424
3425}
3426
Popular Tags