001 /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */
002 package bsh;
003
004 import java.io.*;
005 import java.util.Vector;
006
007 /**
008 This is the BeanShell parser. It is used internally by the Interpreter
009 class (which is probably what you are looking for). The parser knows
010 only how to parse the structure of the language, it does not understand
011 names, commands, etc.
012 <p>
013 You can use the Parser from the command line to do basic structural
014 validation of BeanShell files without actually executing them. e.g.
015 <code><pre>
016 java bsh.Parser [ -p ] file [ file ] [ ... ]
017 </pre></code>
018 <p>
019 The -p option causes the abstract syntax to be printed.
020 <p>
021
022 From code you'd use the Parser like this:
023 <p
024 <code><pre>
025 Parser parser = new Parser(in);
026 while( !(eof=parser.Line()) ) {
027 SimpleNode node = parser.popNode();
028 // use the node, etc. (See bsh.BSH* classes)
029 }
030 </pre></code>
031 */
032 public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants, ParserConstants {/*@bgen(jjtree)*/
033 protected JJTParserState jjtree = new JJTParserState();boolean retainComments = false;
034
035 public void setRetainComments( boolean b ) {
036 retainComments = b;
037 }
038
039 void jjtreeOpenNodeScope(Node n) {
040 ((SimpleNode)n).firstToken = getToken(1);
041 }
042
043 void jjtreeCloseNodeScope(Node n) {
044 ((SimpleNode)n).lastToken = getToken(0);
045 }
046
047 /**
048 Re-initialize the input stream and token source.
049 */
050 void reInitInput( Reader in ) {
051 ReInit(in);
052 }
053
054 public SimpleNode popNode()
055 {
056 if ( jjtree.nodeArity() > 0) // number of child nodes
057 return (SimpleNode)jjtree.popNode();
058 else
059 return null;
060 }
061
062 /**
063 Explicitly re-initialize just the token reader.
064 This seems to be necessary to avoid certain looping errors when
065 reading bogus input. See Interpreter.
066 */
067 void reInitTokenInput( Reader in ) {
068 jj_input_stream.ReInit( in,
069 jj_input_stream.getEndLine(),
070 jj_input_stream.getEndColumn() );
071 }
072
073 public static void main( String [] args )
074 throws IOException, ParseException
075 {
076 boolean print = false;
077 int i=0;
078 if ( args[0].equals("-p") ) {
079 i++;
080 print=true;
081 }
082 for(; i< args.length; i++) {
083 Reader in = new FileReader(args[i]);
084 Parser parser = new Parser(in);
085 parser.setRetainComments(true);
086 while( !parser.Line()/*eof*/ )
087 if ( print )
088 System.out.println( parser.popNode() );
089 }
090 }
091
092 /**
093 Lookahead for the enhanced for statement.
094 Expect "for" "(" and then see whether we hit ":" or a ";" first.
095 */
096 boolean isRegularForStatement()
097 {
098 int curTok = 1;
099 Token tok;
100 tok = getToken(curTok++);
101 if ( tok.kind != FOR ) return false;
102 tok = getToken(curTok++);
103 if ( tok.kind != LPAREN ) return false;
104 while (true)
105 {
106 tok = getToken(curTok++);
107 switch (tok.kind) {
108 case COLON:
109 return false;
110 case SEMICOLON:
111 return true;
112 case EOF:
113 return false;
114 }
115 }
116 }
117
118 /**
119 Generate a ParseException with the specified message, pointing to the
120 current token.
121 The auto-generated Parser.generateParseException() method does not
122 provide line number info, therefore we do this.
123 */
124 ParseException createParseException( String message )
125 {
126 Token errortok = token;
127 int line = errortok.beginLine, column = errortok.beginColumn;
128 String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image;
129 return new ParseException( "Parse error at line " + line
130 + ", column " + column + " : " + message );
131 }
132
133 /*
134 Thanks to Sreenivasa Viswanadha for suggesting how to get rid of expensive
135 lookahead here.
136 */
137 final public boolean Line() throws ParseException {
138 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
139 case 0:
140 jj_consume_token(0);
141 Interpreter.debug("End of File!");
142 {if (true) return true;}
143 break;
144 default:
145 if (jj_2_1(1)) {
146 BlockStatement();
147 {if (true) return false;}
148 } else {
149 jj_consume_token(-1);
150 throw new ParseException();
151 }
152 }
153 throw new Error("Missing return statement in function");
154 }
155
156 /*****************************************
157 * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
158 *****************************************/
159
160 /*
161 Gather modifiers for a class, method, or field.
162 I lookahead is true then we are being called as part of a lookahead and we
163 should not enforce any rules. Otherwise we validate based on context
164 (field, method, class)
165 */
166 final public Modifiers Modifiers(int context, boolean lookahead) throws ParseException {
167 Modifiers mods = null;
168 label_1:
169 while (true) {
170 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
171 case ABSTRACT:
172 case FINAL:
173 case NATIVE:
174 case PRIVATE:
175 case PROTECTED:
176 case PUBLIC:
177 case STATIC:
178 case STRICTFP:
179 case SYNCHRONIZED:
180 case TRANSIENT:
181 case VOLATILE:
182 ;
183 break;
184 default:
185 break label_1;
186 }
187 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
188 case PRIVATE:
189 jj_consume_token(PRIVATE);
190 break;
191 case PROTECTED:
192 jj_consume_token(PROTECTED);
193 break;
194 case PUBLIC:
195 jj_consume_token(PUBLIC);
196 break;
197 case SYNCHRONIZED:
198 jj_consume_token(SYNCHRONIZED);
199 break;
200 case FINAL:
201 jj_consume_token(FINAL);
202 break;
203 case NATIVE:
204 jj_consume_token(NATIVE);
205 break;
206 case TRANSIENT:
207 jj_consume_token(TRANSIENT);
208 break;
209 case VOLATILE:
210 jj_consume_token(VOLATILE);
211 break;
212 case ABSTRACT:
213 jj_consume_token(ABSTRACT);
214 break;
215 case STATIC:
216 jj_consume_token(STATIC);
217 break;
218 case STRICTFP:
219 jj_consume_token(STRICTFP);
220 break;
221 default:
222 jj_consume_token(-1);
223 throw new ParseException();
224 }
225 if ( !lookahead )
226 try {
227 if ( mods == null ) mods = new Modifiers();
228 mods.addModifier( context, getToken(0).image );
229 } catch ( IllegalStateException e ) {
230 {if (true) throw createParseException( e.getMessage() );}
231 }
232 }
233 {if (true) return mods;}
234 throw new Error("Missing return statement in function");
235 }
236
237 /**
238 */
239 final public void ClassDeclaration() throws ParseException {
240 /*@bgen(jjtree) ClassDeclaration */
241 BSHClassDeclaration jjtn000 = new BSHClassDeclaration(JJTCLASSDECLARATION);
242 boolean jjtc000 = true;
243 jjtree.openNodeScope(jjtn000);
244 jjtreeOpenNodeScope(jjtn000);Modifiers mods;
245 Token name;
246 int numInterfaces;
247 try {
248 mods = Modifiers(Modifiers.CLASS, false);
249 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
250 case CLASS:
251 jj_consume_token(CLASS);
252 break;
253 case INTERFACE:
254 jj_consume_token(INTERFACE);
255 jjtn000.isInterface=true;
256 break;
257 default:
258 jj_consume_token(-1);
259 throw new ParseException();
260 }
261 name = jj_consume_token(IDENTIFIER);
262 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
263 case EXTENDS:
264 jj_consume_token(EXTENDS);
265 AmbiguousName();
266 jjtn000.extend = true;
267 break;
268 default:
269 ;
270 }
271 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
272 case IMPLEMENTS:
273 jj_consume_token(IMPLEMENTS);
274 numInterfaces = NameList();
275 jjtn000.numInterfaces=numInterfaces;
276 break;
277 default:
278 ;
279 }
280 Block();
281 jjtree.closeNodeScope(jjtn000, true);
282 jjtc000 = false;
283 jjtreeCloseNodeScope(jjtn000);
284 jjtn000.modifiers = mods;
285 jjtn000.name = name.image;
286 } catch (Throwable jjte000) {
287 if (jjtc000) {
288 jjtree.clearNodeScope(jjtn000);
289 jjtc000 = false;
290 } else {
291 jjtree.popNode();
292 }
293 if (jjte000 instanceof RuntimeException) {
294 {if (true) throw (RuntimeException)jjte000;}
295 }
296 if (jjte000 instanceof ParseException) {
297 {if (true) throw (ParseException)jjte000;}
298 }
299 {if (true) throw (Error)jjte000;}
300 } finally {
301 if (jjtc000) {
302 jjtree.closeNodeScope(jjtn000, true);
303 jjtreeCloseNodeScope(jjtn000);
304 }
305 }
306 }
307
308 final public void MethodDeclaration() throws ParseException {
309 /*@bgen(jjtree) MethodDeclaration */
310 BSHMethodDeclaration jjtn000 = new BSHMethodDeclaration(JJTMETHODDECLARATION);
311 boolean jjtc000 = true;
312 jjtree.openNodeScope(jjtn000);
313 jjtreeOpenNodeScope(jjtn000);Token t = null;
314 Modifiers mods;
315 int count;
316 try {
317 mods = Modifiers(Modifiers.METHOD, false);
318 jjtn000.modifiers = mods;
319 if (jj_2_2(2147483647)) {
320 t = jj_consume_token(IDENTIFIER);
321 jjtn000.name = t.image;
322 } else {
323 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
324 case BOOLEAN:
325 case BYTE:
326 case CHAR:
327 case DOUBLE:
328 case FLOAT:
329 case INT:
330 case LONG:
331 case SHORT:
332 case VOID:
333 case IDENTIFIER:
334 ReturnType();
335 t = jj_consume_token(IDENTIFIER);
336 jjtn000.name = t.image;
337 break;
338 default:
339 jj_consume_token(-1);
340 throw new ParseException();
341 }
342 }
343 FormalParameters();
344 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
345 case THROWS:
346 jj_consume_token(THROWS);
347 count = NameList();
348 jjtn000.numThrows=count;
349 break;
350 default:
351 ;
352 }
353 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
354 case LBRACE:
355 Block();
356 break;
357 case SEMICOLON:
358 jj_consume_token(SEMICOLON);
359 break;
360 default:
361 jj_consume_token(-1);
362 throw new ParseException();
363 }
364 } catch (Throwable jjte000) {
365 if (jjtc000) {
366 jjtree.clearNodeScope(jjtn000);
367 jjtc000 = false;
368 } else {
369 jjtree.popNode();
370 }
371 if (jjte000 instanceof RuntimeException) {
372 {if (true) throw (RuntimeException)jjte000;}
373 }
374 if (jjte000 instanceof ParseException) {
375 {if (true) throw (ParseException)jjte000;}
376 }
377 {if (true) throw (Error)jjte000;}
378 } finally {
379 if (jjtc000) {
380 jjtree.closeNodeScope(jjtn000, true);
381 jjtreeCloseNodeScope(jjtn000);
382 }
383 }
384 }
385
386 final public void PackageDeclaration() throws ParseException {
387 /*@bgen(jjtree) PackageDeclaration */
388 BSHPackageDeclaration jjtn000 = new BSHPackageDeclaration(JJTPACKAGEDECLARATION);
389 boolean jjtc000 = true;
390 jjtree.openNodeScope(jjtn000);
391 jjtreeOpenNodeScope(jjtn000);
392 try {
393 jj_consume_token(PACKAGE);
394 AmbiguousName();
395 } catch (Throwable jjte000) {
396 if (jjtc000) {
397 jjtree.clearNodeScope(jjtn000);
398 jjtc000 = false;
399 } else {
400 jjtree.popNode();
401 }
402 if (jjte000 instanceof RuntimeException) {
403 {if (true) throw (RuntimeException)jjte000;}
404 }
405 if (jjte000 instanceof ParseException) {
406 {if (true) throw (ParseException)jjte000;}
407 }
408 {if (true) throw (Error)jjte000;}
409 } finally {
410 if (jjtc000) {
411 jjtree.closeNodeScope(jjtn000, true);
412 jjtreeCloseNodeScope(jjtn000);
413 }
414 }
415 }
416
417 final public void ImportDeclaration() throws ParseException {
418 /*@bgen(jjtree) ImportDeclaration */
419 BSHImportDeclaration jjtn000 = new BSHImportDeclaration(JJTIMPORTDECLARATION);
420 boolean jjtc000 = true;
421 jjtree.openNodeScope(jjtn000);
422 jjtreeOpenNodeScope(jjtn000);Token s = null;
423 Token t = null;
424 try {
425 if (jj_2_3(3)) {
426 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
427 case STATIC:
428 s = jj_consume_token(STATIC);
429 break;
430 default:
431 ;
432 }
433 jj_consume_token(IMPORT);
434 AmbiguousName();
435 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
436 case DOT:
437 t = jj_consume_token(DOT);
438 jj_consume_token(STAR);
439 break;
440 default:
441 ;
442 }
443 jj_consume_token(SEMICOLON);
444 jjtree.closeNodeScope(jjtn000, true);
445 jjtc000 = false;
446 jjtreeCloseNodeScope(jjtn000);
447 if ( s != null ) jjtn000.staticImport = true;
448 if ( t != null ) jjtn000.importPackage = true;
449 } else {
450 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
451 case IMPORT:
452 jj_consume_token(IMPORT);
453 jj_consume_token(STAR);
454 jj_consume_token(SEMICOLON);
455 jjtree.closeNodeScope(jjtn000, true);
456 jjtc000 = false;
457 jjtreeCloseNodeScope(jjtn000);
458 jjtn000.superImport = true;
459 break;
460 default:
461 jj_consume_token(-1);
462 throw new ParseException();
463 }
464 }
465 } catch (Throwable jjte000) {
466 if (jjtc000) {
467 jjtree.clearNodeScope(jjtn000);
468 jjtc000 = false;
469 } else {
470 jjtree.popNode();
471 }
472 if (jjte000 instanceof RuntimeException) {
473 {if (true) throw (RuntimeException)jjte000;}
474 }
475 if (jjte000 instanceof ParseException) {
476 {if (true) throw (ParseException)jjte000;}
477 }
478 {if (true) throw (Error)jjte000;}
479 } finally {
480 if (jjtc000) {
481 jjtree.closeNodeScope(jjtn000, true);
482 jjtreeCloseNodeScope(jjtn000);
483 }
484 }
485 }
486
487 final public void VariableDeclarator() throws ParseException {
488 /*@bgen(jjtree) VariableDeclarator */
489 BSHVariableDeclarator jjtn000 = new BSHVariableDeclarator(JJTVARIABLEDECLARATOR);
490 boolean jjtc000 = true;
491 jjtree.openNodeScope(jjtn000);
492 jjtreeOpenNodeScope(jjtn000);Token t;
493 try {
494 t = jj_consume_token(IDENTIFIER);
495 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
496 case ASSIGN:
497 jj_consume_token(ASSIGN);
498 VariableInitializer();
499 break;
500 default:
501 ;
502 }
503 jjtree.closeNodeScope(jjtn000, true);
504 jjtc000 = false;
505 jjtreeCloseNodeScope(jjtn000);
506 jjtn000.name = t.image;
507 } catch (Throwable jjte000) {
508 if (jjtc000) {
509 jjtree.clearNodeScope(jjtn000);
510 jjtc000 = false;
511 } else {
512 jjtree.popNode();
513 }
514 if (jjte000 instanceof RuntimeException) {
515 {if (true) throw (RuntimeException)jjte000;}
516 }
517 if (jjte000 instanceof ParseException) {
518 {if (true) throw (ParseException)jjte000;}
519 }
520 {if (true) throw (Error)jjte000;}
521 } finally {
522 if (jjtc000) {
523 jjtree.closeNodeScope(jjtn000, true);
524 jjtreeCloseNodeScope(jjtn000);
525 }
526 }
527 }
528
529 /*
530 this originally handled postfix array dimensions...
531
532 void VariableDeclaratorId() #VariableDeclaratorId :
533 { Token t; }
534 {
535 t=<IDENTIFIER> { jjtThis.name = t.image; }
536 ( "[" "]" { jjtThis.addUndefinedDimension(); } )*
537 }
538 */
539 final public void VariableInitializer() throws ParseException {
540 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
541 case LBRACE:
542 ArrayInitializer();
543 break;
544 case BOOLEAN:
545 case BYTE:
546 case CHAR:
547 case DOUBLE:
548 case FALSE:
549 case FLOAT:
550 case INT:
551 case LONG:
552 case NEW:
553 case NULL:
554 case SHORT:
555 case TRUE:
556 case VOID:
557 case INTEGER_LITERAL:
558 case FLOATING_POINT_LITERAL:
559 case CHARACTER_LITERAL:
560 case STRING_LITERAL:
561 case IDENTIFIER:
562 case LPAREN:
563 case BANG:
564 case TILDE:
565 case INCR:
566 case DECR:
567 case PLUS:
568 case MINUS:
569 Expression();
570 break;
571 default:
572 jj_consume_token(-1);
573 throw new ParseException();
574 }
575 }
576
577 final public void ArrayInitializer() throws ParseException {
578 /*@bgen(jjtree) ArrayInitializer */
579 BSHArrayInitializer jjtn000 = new BSHArrayInitializer(JJTARRAYINITIALIZER);
580 boolean jjtc000 = true;
581 jjtree.openNodeScope(jjtn000);
582 jjtreeOpenNodeScope(jjtn000);
583 try {
584 jj_consume_token(LBRACE);
585 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
586 case BOOLEAN:
587 case BYTE:
588 case CHAR:
589 case DOUBLE:
590 case FALSE:
591 case FLOAT:
592 case INT:
593 case LONG:
594 case NEW:
595 case NULL:
596 case SHORT:
597 case TRUE:
598 case VOID:
599 case INTEGER_LITERAL:
600 case FLOATING_POINT_LITERAL:
601 case CHARACTER_LITERAL:
602 case STRING_LITERAL:
603 case IDENTIFIER:
604 case LPAREN:
605 case LBRACE:
606 case BANG:
607 case TILDE:
608 case INCR:
609 case DECR:
610 case PLUS:
611 case MINUS:
612 VariableInitializer();
613 label_2:
614 while (true) {
615 if (jj_2_4(2)) {
616 ;
617 } else {
618 break label_2;
619 }
620 jj_consume_token(COMMA);
621 VariableInitializer();
622 }
623 break;
624 default:
625 ;
626 }
627 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
628 case COMMA:
629 jj_consume_token(COMMA);
630 break;
631 default:
632 ;
633 }
634 jj_consume_token(RBRACE);
635 } catch (Throwable jjte000) {
636 if (jjtc000) {
637 jjtree.clearNodeScope(jjtn000);
638 jjtc000 = false;
639 } else {
640 jjtree.popNode();
641 }
642 if (jjte000 instanceof RuntimeException) {
643 {if (true) throw (RuntimeException)jjte000;}
644 }
645 if (jjte000 instanceof ParseException) {
646 {if (true) throw (ParseException)jjte000;}
647 }
648 {if (true) throw (Error)jjte000;}
649 } finally {
650 if (jjtc000) {
651 jjtree.closeNodeScope(jjtn000, true);
652 jjtreeCloseNodeScope(jjtn000);
653 }
654 }
655 }
656
657 final public void FormalParameters() throws ParseException {
658 /*@bgen(jjtree) FormalParameters */
659 BSHFormalParameters jjtn000 = new BSHFormalParameters(JJTFORMALPARAMETERS);
660 boolean jjtc000 = true;
661 jjtree.openNodeScope(jjtn000);
662 jjtreeOpenNodeScope(jjtn000);
663 try {
664 jj_consume_token(LPAREN);
665 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
666 case BOOLEAN:
667 case BYTE:
668 case CHAR:
669 case DOUBLE:
670 case FLOAT:
671 case INT:
672 case LONG:
673 case SHORT:
674 case IDENTIFIER:
675 FormalParameter();
676 label_3:
677 while (true) {
678 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
679 case COMMA:
680 ;
681 break;
682 default:
683 break label_3;
684 }
685 jj_consume_token(COMMA);
686 FormalParameter();
687 }
688 break;
689 default:
690 ;
691 }
692 jj_consume_token(RPAREN);
693 } catch (Throwable jjte000) {
694 if (jjtc000) {
695 jjtree.clearNodeScope(jjtn000);
696 jjtc000 = false;
697 } else {
698 jjtree.popNode();
699 }
700 if (jjte000 instanceof RuntimeException) {
701 {if (true) throw (RuntimeException)jjte000;}
702 }
703 if (jjte000 instanceof ParseException) {
704 {if (true) throw (ParseException)jjte000;}
705 }
706 {if (true) throw (Error)jjte000;}
707 } finally {
708 if (jjtc000) {
709 jjtree.closeNodeScope(jjtn000, true);
710 jjtreeCloseNodeScope(jjtn000);
711 }
712 }
713 }
714
715 final public void FormalParameter() throws ParseException {
716 /*@bgen(jjtree) FormalParameter */
717 BSHFormalParameter jjtn000 = new BSHFormalParameter(JJTFORMALPARAMETER);
718 boolean jjtc000 = true;
719 jjtree.openNodeScope(jjtn000);
720 jjtreeOpenNodeScope(jjtn000);Token t;
721 try {
722 if (jj_2_5(2)) {
723 Type();
724 t = jj_consume_token(IDENTIFIER);
725 jjtree.closeNodeScope(jjtn000, true);
726 jjtc000 = false;
727 jjtreeCloseNodeScope(jjtn000);
728 jjtn000.name = t.image;
729 } else {
730 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
731 case IDENTIFIER:
732 t = jj_consume_token(IDENTIFIER);
733 jjtree.closeNodeScope(jjtn000, true);
734 jjtc000 = false;
735 jjtreeCloseNodeScope(jjtn000);
736 jjtn000.name = t.image;
737 break;
738 default:
739 jj_consume_token(-1);
740 throw new ParseException();
741 }
742 }
743 } catch (Throwable jjte000) {
744 if (jjtc000) {
745 jjtree.clearNodeScope(jjtn000);
746 jjtc000 = false;
747 } else {
748 jjtree.popNode();
749 }
750 if (jjte000 instanceof RuntimeException) {
751 {if (true) throw (RuntimeException)jjte000;}
752 }
753 if (jjte000 instanceof ParseException) {
754 {if (true) throw (ParseException)jjte000;}
755 }
756 {if (true) throw (Error)jjte000;}
757 } finally {
758 if (jjtc000) {
759 jjtree.closeNodeScope(jjtn000, true);
760 jjtreeCloseNodeScope(jjtn000);
761 }
762 }
763 }
764
765 /*
766 Type, name and expression syntax follows.
767 */
768 final public void Type() throws ParseException {
769 /*@bgen(jjtree) Type */
770 BSHType jjtn000 = new BSHType(JJTTYPE);
771 boolean jjtc000 = true;
772 jjtree.openNodeScope(jjtn000);
773 jjtreeOpenNodeScope(jjtn000);
774 try {
775 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
776 case BOOLEAN:
777 case BYTE:
778 case CHAR:
779 case DOUBLE:
780 case FLOAT:
781 case INT:
782 case LONG:
783 case SHORT:
784 PrimitiveType();
785 break;
786 case IDENTIFIER:
787 AmbiguousName();
788 break;
789 default:
790 jj_consume_token(-1);
791 throw new ParseException();
792 }
793 label_4:
794 while (true) {
795 if (jj_2_6(2)) {
796 ;
797 } else {
798 break label_4;
799 }
800 jj_consume_token(LBRACKET);
801 jj_consume_token(RBRACKET);
802 jjtn000.addArrayDimension();
803 }
804 } catch (Throwable jjte000) {
805 if (jjtc000) {
806 jjtree.clearNodeScope(jjtn000);
807 jjtc000 = false;
808 } else {
809 jjtree.popNode();
810 }
811 if (jjte000 instanceof RuntimeException) {
812 {if (true) throw (RuntimeException)jjte000;}
813 }
814 if (jjte000 instanceof ParseException) {
815 {if (true) throw (ParseException)jjte000;}
816 }
817 {if (true) throw (Error)jjte000;}
818 } finally {
819 if (jjtc000) {
820 jjtree.closeNodeScope(jjtn000, true);
821 jjtreeCloseNodeScope(jjtn000);
822 }
823 }
824 }
825
826 /*
827 Originally called ResultType in the grammar
828 */
829 final public void ReturnType() throws ParseException {
830 /*@bgen(jjtree) ReturnType */
831 BSHReturnType jjtn000 = new BSHReturnType(JJTRETURNTYPE);
832 boolean jjtc000 = true;
833 jjtree.openNodeScope(jjtn000);
834 jjtreeOpenNodeScope(jjtn000);
835 try {
836 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
837 case VOID:
838 jj_consume_token(VOID);
839 jjtree.closeNodeScope(jjtn000, true);
840 jjtc000 = false;
841 jjtreeCloseNodeScope(jjtn000);
842 jjtn000.isVoid = true;
843 break;
844 case BOOLEAN:
845 case BYTE:
846 case CHAR:
847 case DOUBLE:
848 case FLOAT:
849 case INT:
850 case LONG:
851 case SHORT:
852 case IDENTIFIER:
853 Type();
854 break;
855 default:
856 jj_consume_token(-1);
857 throw new ParseException();
858 }
859 } catch (Throwable jjte000) {
860 if (jjtc000) {
861 jjtree.clearNodeScope(jjtn000);
862 jjtc000 = false;
863 } else {
864 jjtree.popNode();
865 }
866 if (jjte000 instanceof RuntimeException) {
867 {if (true) throw (RuntimeException)jjte000;}
868 }
869 if (jjte000 instanceof ParseException) {
870 {if (true) throw (ParseException)jjte000;}
871 }
872 {if (true) throw (Error)jjte000;}
873 } finally {
874 if (jjtc000) {
875 jjtree.closeNodeScope(jjtn000, true);
876 jjtreeCloseNodeScope(jjtn000);
877 }
878 }
879 }
880
881 final public void PrimitiveType() throws ParseException {
882 /*@bgen(jjtree) PrimitiveType */
883 BSHPrimitiveType jjtn000 = new BSHPrimitiveType(JJTPRIMITIVETYPE);
884 boolean jjtc000 = true;
885 jjtree.openNodeScope(jjtn000);
886 jjtreeOpenNodeScope(jjtn000);
887 try {
888 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
889 case BOOLEAN:
890 jj_consume_token(BOOLEAN);
891 jjtree.closeNodeScope(jjtn000, true);
892 jjtc000 = false;
893 jjtreeCloseNodeScope(jjtn000);
894 jjtn000.type = Boolean.TYPE;
895 break;
896 case CHAR:
897 jj_consume_token(CHAR);
898 jjtree.closeNodeScope(jjtn000, true);
899 jjtc000 = false;
900 jjtreeCloseNodeScope(jjtn000);
901 jjtn000.type = Character.TYPE;
902 break;
903 case BYTE:
904 jj_consume_token(BYTE);
905 jjtree.closeNodeScope(jjtn000, true);
906 jjtc000 = false;
907 jjtreeCloseNodeScope(jjtn000);
908 jjtn000.type = Byte.TYPE;
909 break;
910 case SHORT:
911 jj_consume_token(SHORT);
912 jjtree.closeNodeScope(jjtn000, true);
913 jjtc000 = false;
914 jjtreeCloseNodeScope(jjtn000);
915 jjtn000.type = Short.TYPE;
916 break;
917 case INT:
918 jj_consume_token(INT);
919 jjtree.closeNodeScope(jjtn000, true);
920 jjtc000 = false;
921 jjtreeCloseNodeScope(jjtn000);
922 jjtn000.type = Integer.TYPE;
923 break;
924 case LONG:
925 jj_consume_token(LONG);
926 jjtree.closeNodeScope(jjtn000, true);
927 jjtc000 = false;
928 jjtreeCloseNodeScope(jjtn000);
929 jjtn000.type = Long.TYPE;
930 break;
931 case FLOAT:
932 jj_consume_token(FLOAT);
933 jjtree.closeNodeScope(jjtn000, true);
934 jjtc000 = false;
935 jjtreeCloseNodeScope(jjtn000);
936 jjtn000.type = Float.TYPE;
937 break;
938 case DOUBLE:
939 jj_consume_token(DOUBLE);
940 jjtree.closeNodeScope(jjtn000, true);
941 jjtc000 = false;
942 jjtreeCloseNodeScope(jjtn000);
943 jjtn000.type = Double.TYPE;
944 break;
945 default:
946 jj_consume_token(-1);
947 throw new ParseException();
948 }
949 } finally {
950 if (jjtc000) {
951 jjtree.closeNodeScope(jjtn000, true);
952 jjtreeCloseNodeScope(jjtn000);
953 }
954 }
955 }
956
957 final public void AmbiguousName() throws ParseException {
958 /*@bgen(jjtree) AmbiguousName */
959 BSHAmbiguousName jjtn000 = new BSHAmbiguousName(JJTAMBIGUOUSNAME);
960 boolean jjtc000 = true;
961 jjtree.openNodeScope(jjtn000);
962 jjtreeOpenNodeScope(jjtn000);Token t;
963 StringBuffer s;
964 try {
965 t = jj_consume_token(IDENTIFIER);
966 s = new StringBuffer(t.image);
967 label_5:
968 while (true) {
969 if (jj_2_7(2)) {
970 ;
971 } else {
972 break label_5;
973 }
974 jj_consume_token(DOT);
975 t = jj_consume_token(IDENTIFIER);
976 s.append("."+t.image);
977 }
978 jjtree.closeNodeScope(jjtn000, true);
979 jjtc000 = false;
980 jjtreeCloseNodeScope(jjtn000);
981 jjtn000.text = s.toString();
982 } finally {
983 if (jjtc000) {
984 jjtree.closeNodeScope(jjtn000, true);
985 jjtreeCloseNodeScope(jjtn000);
986 }
987 }
988 }
989
990 final public int NameList() throws ParseException {
991 int count = 0;
992 AmbiguousName();
993 ++count;
994 label_6:
995 while (true) {
996 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
997 case COMMA:
998 ;
999 break;
1000 default:
1001 break label_6;
1002 }
1003 jj_consume_token(COMMA);
1004 AmbiguousName();
1005 ++count;
1006 }
1007 {if (true) return count;}
1008 throw new Error("Missing return statement in function");
1009 }
1010
1011 /*
1012 * Expression syntax follows.
1013 */
1014 final public void Expression() throws ParseException {
1015 if (jj_2_8(2147483647)) {
1016 Assignment();
1017 } else {
1018 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1019 case BOOLEAN:
1020 case BYTE:
1021 case CHAR:
1022 case DOUBLE:
1023 case FALSE:
1024 case FLOAT:
1025 case INT:
1026 case LONG:
1027 case NEW:
1028 case NULL:
1029 case SHORT:
1030 case TRUE:
1031 case VOID:
1032 case INTEGER_LITERAL:
1033 case FLOATING_POINT_LITERAL:
1034 case CHARACTER_LITERAL:
1035 case STRING_LITERAL:
1036 case IDENTIFIER:
1037 case LPAREN:
1038 case BANG:
1039 case TILDE:
1040 case INCR:
1041 case DECR:
1042 case PLUS:
1043 case MINUS:
1044 ConditionalExpression();
1045 break;
1046 default:
1047 jj_consume_token(-1);
1048 throw new ParseException();
1049 }
1050 }
1051 }
1052
1053 final public void Assignment() throws ParseException {
1054 /*@bgen(jjtree) Assignment */
1055 BSHAssignment jjtn000 = new BSHAssignment(JJTASSIGNMENT);
1056 boolean jjtc000 = true;
1057 jjtree.openNodeScope(jjtn000);
1058 jjtreeOpenNodeScope(jjtn000);int op ;
1059 try {
1060 PrimaryExpression();
1061 op = AssignmentOperator();
1062 jjtn000.operator = op;
1063 Expression();
1064 } catch (Throwable jjte000) {
1065 if (jjtc000) {
1066 jjtree.clearNodeScope(jjtn000);
1067 jjtc000 = false;
1068 } else {
1069 jjtree.popNode();
1070 }
1071 if (jjte000 instanceof RuntimeException) {
1072 {if (true) throw (RuntimeException)jjte000;}
1073 }
1074 if (jjte000 instanceof ParseException) {
1075 {if (true) throw (ParseException)jjte000;}
1076 }
1077 {if (true) throw (Error)jjte000;}
1078 } finally {
1079 if (jjtc000) {
1080 jjtree.closeNodeScope(jjtn000, true);
1081 jjtreeCloseNodeScope(jjtn000);
1082 }
1083 }
1084 }
1085
1086 final public int AssignmentOperator() throws ParseException {
1087 Token t;
1088 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1089 case ASSIGN:
1090 jj_consume_token(ASSIGN);
1091 break;
1092 case STARASSIGN:
1093 jj_consume_token(STARASSIGN);
1094 break;
1095 case SLASHASSIGN:
1096 jj_consume_token(SLASHASSIGN);
1097 break;
1098 case MODASSIGN:
1099 jj_consume_token(MODASSIGN);
1100 break;
1101 case PLUSASSIGN:
1102 jj_consume_token(PLUSASSIGN);
1103 break;
1104 case MINUSASSIGN:
1105 jj_consume_token(MINUSASSIGN);
1106 break;
1107 case ANDASSIGN:
1108 jj_consume_token(ANDASSIGN);
1109 break;
1110 case XORASSIGN:
1111 jj_consume_token(XORASSIGN);
1112 break;
1113 case ORASSIGN:
1114 jj_consume_token(ORASSIGN);
1115 break;
1116 case LSHIFTASSIGN:
1117 jj_consume_token(LSHIFTASSIGN);
1118 break;
1119 case LSHIFTASSIGNX:
1120 jj_consume_token(LSHIFTASSIGNX);
1121 break;
1122 case RSIGNEDSHIFTASSIGN:
1123 jj_consume_token(RSIGNEDSHIFTASSIGN);
1124 break;
1125 case RSIGNEDSHIFTASSIGNX:
1126 jj_consume_token(RSIGNEDSHIFTASSIGNX);
1127 break;
1128 case RUNSIGNEDSHIFTASSIGN:
1129 jj_consume_token(RUNSIGNEDSHIFTASSIGN);
1130 break;
1131 case RUNSIGNEDSHIFTASSIGNX:
1132 jj_consume_token(RUNSIGNEDSHIFTASSIGNX);
1133 break;
1134 default:
1135 jj_consume_token(-1);
1136 throw new ParseException();
1137 }
1138 t = getToken(0);
1139 {if (true) return t.kind;}
1140 throw new Error("Missing return statement in function");
1141 }
1142
1143 final public void ConditionalExpression() throws ParseException {
1144 ConditionalOrExpression();
1145 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1146 case HOOK:
1147 jj_consume_token(HOOK);
1148 Expression();
1149 jj_consume_token(COLON);
1150 BSHTernaryExpression jjtn001 = new BSHTernaryExpression(JJTTERNARYEXPRESSION);
1151 boolean jjtc001 = true;
1152 jjtree.openNodeScope(jjtn001);
1153 jjtreeOpenNodeScope(jjtn001);
1154 try {
1155 ConditionalExpression();
1156 } catch (Throwable jjte001) {
1157 if (jjtc001) {
1158 jjtree.clearNodeScope(jjtn001);
1159 jjtc001 = false;
1160 } else {
1161 jjtree.popNode();
1162 }
1163 if (jjte001 instanceof RuntimeException) {
1164 {if (true) throw (RuntimeException)jjte001;}
1165 }
1166 if (jjte001 instanceof ParseException) {
1167 {if (true) throw (ParseException)jjte001;}
1168 }
1169 {if (true) throw (Error)jjte001;}
1170 } finally {
1171 if (jjtc001) {
1172 jjtree.closeNodeScope(jjtn001, 3);
1173 jjtreeCloseNodeScope(jjtn001);
1174 }
1175 }
1176 break;
1177 default:
1178 ;
1179 }
1180 }
1181
1182 final public void ConditionalOrExpression() throws ParseException {
1183 Token t=null;
1184 ConditionalAndExpression();
1185 label_7:
1186 while (true) {
1187 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1188 case BOOL_OR:
1189 case BOOL_ORX:
1190 ;
1191 break;
1192 default:
1193 break label_7;
1194 }
1195 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1196 case BOOL_OR:
1197 t = jj_consume_token(BOOL_OR);
1198 break;
1199 case BOOL_ORX:
1200 t = jj_consume_token(BOOL_ORX);
1201 break;
1202 default:
1203 jj_consume_token(-1);
1204 throw new ParseException();
1205 }
1206 ConditionalAndExpression();
1207 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1208 boolean jjtc001 = true;
1209 jjtree.openNodeScope(jjtn001);
1210 jjtreeOpenNodeScope(jjtn001);
1211 try {
1212 jjtree.closeNodeScope(jjtn001, 2);
1213 jjtc001 = false;
1214 jjtreeCloseNodeScope(jjtn001);
1215 jjtn001.kind = t.kind;
1216 } finally {
1217 if (jjtc001) {
1218 jjtree.closeNodeScope(jjtn001, 2);
1219 jjtreeCloseNodeScope(jjtn001);
1220 }
1221 }
1222 }
1223 }
1224
1225 final public void ConditionalAndExpression() throws ParseException {
1226 Token t=null;
1227 InclusiveOrExpression();
1228 label_8:
1229 while (true) {
1230 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1231 case BOOL_AND:
1232 case BOOL_ANDX:
1233 ;
1234 break;
1235 default:
1236 break label_8;
1237 }
1238 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1239 case BOOL_AND:
1240 t = jj_consume_token(BOOL_AND);
1241 break;
1242 case BOOL_ANDX:
1243 t = jj_consume_token(BOOL_ANDX);
1244 break;
1245 default:
1246 jj_consume_token(-1);
1247 throw new ParseException();
1248 }
1249 InclusiveOrExpression();
1250 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1251 boolean jjtc001 = true;
1252 jjtree.openNodeScope(jjtn001);
1253 jjtreeOpenNodeScope(jjtn001);
1254 try {
1255 jjtree.closeNodeScope(jjtn001, 2);
1256 jjtc001 = false;
1257 jjtreeCloseNodeScope(jjtn001);
1258 jjtn001.kind = t.kind;
1259 } finally {
1260 if (jjtc001) {
1261 jjtree.closeNodeScope(jjtn001, 2);
1262 jjtreeCloseNodeScope(jjtn001);
1263 }
1264 }
1265 }
1266 }
1267
1268 final public void InclusiveOrExpression() throws ParseException {
1269 Token t=null;
1270 ExclusiveOrExpression();
1271 label_9:
1272 while (true) {
1273 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1274 case BIT_OR:
1275 case BIT_ORX:
1276 ;
1277 break;
1278 default:
1279 break label_9;
1280 }
1281 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1282 case BIT_OR:
1283 t = jj_consume_token(BIT_OR);
1284 break;
1285 case BIT_ORX:
1286 t = jj_consume_token(BIT_ORX);
1287 break;
1288 default:
1289 jj_consume_token(-1);
1290 throw new ParseException();
1291 }
1292 ExclusiveOrExpression();
1293 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1294 boolean jjtc001 = true;
1295 jjtree.openNodeScope(jjtn001);
1296 jjtreeOpenNodeScope(jjtn001);
1297 try {
1298 jjtree.closeNodeScope(jjtn001, 2);
1299 jjtc001 = false;
1300 jjtreeCloseNodeScope(jjtn001);
1301 jjtn001.kind = t.kind;
1302 } finally {
1303 if (jjtc001) {
1304 jjtree.closeNodeScope(jjtn001, 2);
1305 jjtreeCloseNodeScope(jjtn001);
1306 }
1307 }
1308 }
1309 }
1310
1311 final public void ExclusiveOrExpression() throws ParseException {
1312 Token t=null;
1313 AndExpression();
1314 label_10:
1315 while (true) {
1316 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1317 case XOR:
1318 ;
1319 break;
1320 default:
1321 break label_10;
1322 }
1323 t = jj_consume_token(XOR);
1324 AndExpression();
1325 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1326 boolean jjtc001 = true;
1327 jjtree.openNodeScope(jjtn001);
1328 jjtreeOpenNodeScope(jjtn001);
1329 try {
1330 jjtree.closeNodeScope(jjtn001, 2);
1331 jjtc001 = false;
1332 jjtreeCloseNodeScope(jjtn001);
1333 jjtn001.kind = t.kind;
1334 } finally {
1335 if (jjtc001) {
1336 jjtree.closeNodeScope(jjtn001, 2);
1337 jjtreeCloseNodeScope(jjtn001);
1338 }
1339 }
1340 }
1341 }
1342
1343 final public void AndExpression() throws ParseException {
1344 Token t=null;
1345 EqualityExpression();
1346 label_11:
1347 while (true) {
1348 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1349 case BIT_AND:
1350 case BIT_ANDX:
1351 ;
1352 break;
1353 default:
1354 break label_11;
1355 }
1356 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1357 case BIT_AND:
1358 t = jj_consume_token(BIT_AND);
1359 break;
1360 case BIT_ANDX:
1361 t = jj_consume_token(BIT_ANDX);
1362 break;
1363 default:
1364 jj_consume_token(-1);
1365 throw new ParseException();
1366 }
1367 EqualityExpression();
1368 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1369 boolean jjtc001 = true;
1370 jjtree.openNodeScope(jjtn001);
1371 jjtreeOpenNodeScope(jjtn001);
1372 try {
1373 jjtree.closeNodeScope(jjtn001, 2);
1374 jjtc001 = false;
1375 jjtreeCloseNodeScope(jjtn001);
1376 jjtn001.kind = t.kind;
1377 } finally {
1378 if (jjtc001) {
1379 jjtree.closeNodeScope(jjtn001, 2);
1380 jjtreeCloseNodeScope(jjtn001);
1381 }
1382 }
1383 }
1384 }
1385
1386 final public void EqualityExpression() throws ParseException {
1387 Token t = null;
1388 InstanceOfExpression();
1389 label_12:
1390 while (true) {
1391 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1392 case EQ:
1393 case NE:
1394 ;
1395 break;
1396 default:
1397 break label_12;
1398 }
1399 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1400 case EQ:
1401 t = jj_consume_token(EQ);
1402 break;
1403 case NE:
1404 t = jj_consume_token(NE);
1405 break;
1406 default:
1407 jj_consume_token(-1);
1408 throw new ParseException();
1409 }
1410 InstanceOfExpression();
1411 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1412 boolean jjtc001 = true;
1413 jjtree.openNodeScope(jjtn001);
1414 jjtreeOpenNodeScope(jjtn001);
1415 try {
1416 jjtree.closeNodeScope(jjtn001, 2);
1417 jjtc001 = false;
1418 jjtreeCloseNodeScope(jjtn001);
1419 jjtn001.kind = t.kind;
1420 } finally {
1421 if (jjtc001) {
1422 jjtree.closeNodeScope(jjtn001, 2);
1423 jjtreeCloseNodeScope(jjtn001);
1424 }
1425 }
1426 }
1427 }
1428
1429 final public void InstanceOfExpression() throws ParseException {
1430 Token t = null;
1431 RelationalExpression();
1432 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1433 case INSTANCEOF:
1434 t = jj_consume_token(INSTANCEOF);
1435 Type();
1436 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1437 boolean jjtc001 = true;
1438 jjtree.openNodeScope(jjtn001);
1439 jjtreeOpenNodeScope(jjtn001);
1440 try {
1441 jjtree.closeNodeScope(jjtn001, 2);
1442 jjtc001 = false;
1443 jjtreeCloseNodeScope(jjtn001);
1444 jjtn001.kind = t.kind;
1445 } finally {
1446 if (jjtc001) {
1447 jjtree.closeNodeScope(jjtn001, 2);
1448 jjtreeCloseNodeScope(jjtn001);
1449 }
1450 }
1451 break;
1452 default:
1453 ;
1454 }
1455 }
1456
1457 final public void RelationalExpression() throws ParseException {
1458 Token t = null;
1459 ShiftExpression();
1460 label_13:
1461 while (true) {
1462 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1463 case GT:
1464 case GTX:
1465 case LT:
1466 case LTX:
1467 case LE:
1468 case LEX:
1469 case GE:
1470 case GEX:
1471 ;
1472 break;
1473 default:
1474 break label_13;
1475 }
1476 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1477 case LT:
1478 t = jj_consume_token(LT);
1479 break;
1480 case LTX:
1481 t = jj_consume_token(LTX);
1482 break;
1483 case GT:
1484 t = jj_consume_token(GT);
1485 break;
1486 case GTX:
1487 t = jj_consume_token(GTX);
1488 break;
1489 case LE:
1490 t = jj_consume_token(LE);
1491 break;
1492 case LEX:
1493 t = jj_consume_token(LEX);
1494 break;
1495 case GE:
1496 t = jj_consume_token(GE);
1497 break;
1498 case GEX:
1499 t = jj_consume_token(GEX);
1500 break;
1501 default:
1502 jj_consume_token(-1);
1503 throw new ParseException();
1504 }
1505 ShiftExpression();
1506 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1507 boolean jjtc001 = true;
1508 jjtree.openNodeScope(jjtn001);
1509 jjtreeOpenNodeScope(jjtn001);
1510 try {
1511 jjtree.closeNodeScope(jjtn001, 2);
1512 jjtc001 = false;
1513 jjtreeCloseNodeScope(jjtn001);
1514 jjtn001.kind = t.kind;
1515 } finally {
1516 if (jjtc001) {
1517 jjtree.closeNodeScope(jjtn001, 2);
1518 jjtreeCloseNodeScope(jjtn001);
1519 }
1520 }
1521 }
1522 }
1523
1524 final public void ShiftExpression() throws ParseException {
1525 Token t = null;
1526 AdditiveExpression();
1527 label_14:
1528 while (true) {
1529 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1530 case LSHIFT:
1531 case LSHIFTX:
1532 case RSIGNEDSHIFT:
1533 case RSIGNEDSHIFTX:
1534 case RUNSIGNEDSHIFT:
1535 case RUNSIGNEDSHIFTX:
1536 ;
1537 break;
1538 default:
1539 break label_14;
1540 }
1541 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1542 case LSHIFT:
1543 t = jj_consume_token(LSHIFT);
1544 break;
1545 case LSHIFTX:
1546 t = jj_consume_token(LSHIFTX);
1547 break;
1548 case RSIGNEDSHIFT:
1549 t = jj_consume_token(RSIGNEDSHIFT);
1550 break;
1551 case RSIGNEDSHIFTX:
1552 t = jj_consume_token(RSIGNEDSHIFTX);
1553 break;
1554 case RUNSIGNEDSHIFT:
1555 t = jj_consume_token(RUNSIGNEDSHIFT);
1556 break;
1557 case RUNSIGNEDSHIFTX:
1558 t = jj_consume_token(RUNSIGNEDSHIFTX);
1559 break;
1560 default:
1561 jj_consume_token(-1);
1562 throw new ParseException();
1563 }
1564 AdditiveExpression();
1565 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1566 boolean jjtc001 = true;
1567 jjtree.openNodeScope(jjtn001);
1568 jjtreeOpenNodeScope(jjtn001);
1569 try {
1570 jjtree.closeNodeScope(jjtn001, 2);
1571 jjtc001 = false;
1572 jjtreeCloseNodeScope(jjtn001);
1573 jjtn001.kind = t.kind;
1574 } finally {
1575 if (jjtc001) {
1576 jjtree.closeNodeScope(jjtn001, 2);
1577 jjtreeCloseNodeScope(jjtn001);
1578 }
1579 }
1580 }
1581 }
1582
1583 final public void AdditiveExpression() throws ParseException {
1584 Token t = null;
1585 MultiplicativeExpression();
1586 label_15:
1587 while (true) {
1588 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1589 case PLUS:
1590 case MINUS:
1591 ;
1592 break;
1593 default:
1594 break label_15;
1595 }
1596 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1597 case PLUS:
1598 t = jj_consume_token(PLUS);
1599 break;
1600 case MINUS:
1601 t = jj_consume_token(MINUS);
1602 break;
1603 default:
1604 jj_consume_token(-1);
1605 throw new ParseException();
1606 }
1607 MultiplicativeExpression();
1608 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1609 boolean jjtc001 = true;
1610 jjtree.openNodeScope(jjtn001);
1611 jjtreeOpenNodeScope(jjtn001);
1612 try {
1613 jjtree.closeNodeScope(jjtn001, 2);
1614 jjtc001 = false;
1615 jjtreeCloseNodeScope(jjtn001);
1616 jjtn001.kind = t.kind;
1617 } finally {
1618 if (jjtc001) {
1619 jjtree.closeNodeScope(jjtn001, 2);
1620 jjtreeCloseNodeScope(jjtn001);
1621 }
1622 }
1623 }
1624 }
1625
1626 final public void MultiplicativeExpression() throws ParseException {
1627 Token t = null;
1628 UnaryExpression();
1629 label_16:
1630 while (true) {
1631 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1632 case STAR:
1633 case SLASH:
1634 case MOD:
1635 ;
1636 break;
1637 default:
1638 break label_16;
1639 }
1640 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1641 case STAR:
1642 t = jj_consume_token(STAR);
1643 break;
1644 case SLASH:
1645 t = jj_consume_token(SLASH);
1646 break;
1647 case MOD:
1648 t = jj_consume_token(MOD);
1649 break;
1650 default:
1651 jj_consume_token(-1);
1652 throw new ParseException();
1653 }
1654 UnaryExpression();
1655 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1656 boolean jjtc001 = true;
1657 jjtree.openNodeScope(jjtn001);
1658 jjtreeOpenNodeScope(jjtn001);
1659 try {
1660 jjtree.closeNodeScope(jjtn001, 2);
1661 jjtc001 = false;
1662 jjtreeCloseNodeScope(jjtn001);
1663 jjtn001.kind = t.kind;
1664 } finally {
1665 if (jjtc001) {
1666 jjtree.closeNodeScope(jjtn001, 2);
1667 jjtreeCloseNodeScope(jjtn001);
1668 }
1669 }
1670 }
1671 }
1672
1673 final public void UnaryExpression() throws ParseException {
1674 Token t = null;
1675 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1676 case PLUS:
1677 case MINUS:
1678 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1679 case PLUS:
1680 t = jj_consume_token(PLUS);
1681 break;
1682 case MINUS:
1683 t = jj_consume_token(MINUS);
1684 break;
1685 default:
1686 jj_consume_token(-1);
1687 throw new ParseException();
1688 }
1689 UnaryExpression();
1690 BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1691 boolean jjtc001 = true;
1692 jjtree.openNodeScope(jjtn001);
1693 jjtreeOpenNodeScope(jjtn001);
1694 try {
1695 jjtree.closeNodeScope(jjtn001, 1);
1696 jjtc001 = false;
1697 jjtreeCloseNodeScope(jjtn001);
1698 jjtn001.kind = t.kind;
1699 } finally {
1700 if (jjtc001) {
1701 jjtree.closeNodeScope(jjtn001, 1);
1702 jjtreeCloseNodeScope(jjtn001);
1703 }
1704 }
1705 break;
1706 case INCR:
1707 PreIncrementExpression();
1708 break;
1709 case DECR:
1710 PreDecrementExpression();
1711 break;
1712 case BOOLEAN:
1713 case BYTE:
1714 case CHAR:
1715 case DOUBLE:
1716 case FALSE:
1717 case FLOAT:
1718 case INT:
1719 case LONG:
1720 case NEW:
1721 case NULL:
1722 case SHORT:
1723 case TRUE:
1724 case VOID:
1725 case INTEGER_LITERAL:
1726 case FLOATING_POINT_LITERAL:
1727 case CHARACTER_LITERAL:
1728 case STRING_LITERAL:
1729 case IDENTIFIER:
1730 case LPAREN:
1731 case BANG:
1732 case TILDE:
1733 UnaryExpressionNotPlusMinus();
1734 break;
1735 default:
1736 jj_consume_token(-1);
1737 throw new ParseException();
1738 }
1739 }
1740
1741 final public void PreIncrementExpression() throws ParseException {
1742 Token t = null;
1743 t = jj_consume_token(INCR);
1744 PrimaryExpression();
1745 BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1746 boolean jjtc001 = true;
1747 jjtree.openNodeScope(jjtn001);
1748 jjtreeOpenNodeScope(jjtn001);
1749 try {
1750 jjtree.closeNodeScope(jjtn001, 1);
1751 jjtc001 = false;
1752 jjtreeCloseNodeScope(jjtn001);
1753 jjtn001.kind = t.kind;
1754 } finally {
1755 if (jjtc001) {
1756 jjtree.closeNodeScope(jjtn001, 1);
1757 jjtreeCloseNodeScope(jjtn001);
1758 }
1759 }
1760 }
1761
1762 final public void PreDecrementExpression() throws ParseException {
1763 Token t = null;
1764 t = jj_consume_token(DECR);
1765 PrimaryExpression();
1766 BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1767 boolean jjtc001 = true;
1768 jjtree.openNodeScope(jjtn001);
1769 jjtreeOpenNodeScope(jjtn001);
1770 try {
1771 jjtree.closeNodeScope(jjtn001, 1);
1772 jjtc001 = false;
1773 jjtreeCloseNodeScope(jjtn001);
1774 jjtn001.kind = t.kind;
1775 } finally {
1776 if (jjtc001) {
1777 jjtree.closeNodeScope(jjtn001, 1);
1778 jjtreeCloseNodeScope(jjtn001);
1779 }
1780 }
1781 }
1782
1783 final public void UnaryExpressionNotPlusMinus() throws ParseException {
1784 Token t = null;
1785 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1786 case BANG:
1787 case TILDE:
1788 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1789 case TILDE:
1790 t = jj_consume_token(TILDE);
1791 break;
1792 case BANG:
1793 t = jj_consume_token(BANG);
1794 break;
1795 default:
1796 jj_consume_token(-1);
1797 throw new ParseException();
1798 }
1799 UnaryExpression();
1800 BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1801 boolean jjtc001 = true;
1802 jjtree.openNodeScope(jjtn001);
1803 jjtreeOpenNodeScope(jjtn001);
1804 try {
1805 jjtree.closeNodeScope(jjtn001, 1);
1806 jjtc001 = false;
1807 jjtreeCloseNodeScope(jjtn001);
1808 jjtn001.kind = t.kind;
1809 } finally {
1810 if (jjtc001) {
1811 jjtree.closeNodeScope(jjtn001, 1);
1812 jjtreeCloseNodeScope(jjtn001);
1813 }
1814 }
1815 break;
1816 default:
1817 if (jj_2_9(2147483647)) {
1818 CastExpression();
1819 } else {
1820 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1821 case BOOLEAN:
1822 case BYTE:
1823 case CHAR:
1824 case DOUBLE:
1825 case FALSE:
1826 case FLOAT:
1827 case INT:
1828 case LONG:
1829 case NEW:
1830 case NULL:
1831 case SHORT:
1832 case TRUE:
1833 case VOID:
1834 case INTEGER_LITERAL:
1835 case FLOATING_POINT_LITERAL:
1836 case CHARACTER_LITERAL:
1837 case STRING_LITERAL:
1838 case IDENTIFIER:
1839 case LPAREN:
1840 PostfixExpression();
1841 break;
1842 default:
1843 jj_consume_token(-1);
1844 throw new ParseException();
1845 }
1846 }
1847 }
1848 }
1849
1850 // This production is to determine lookahead only.
1851 final public void CastLookahead() throws ParseException {
1852 if (jj_2_10(2)) {
1853 jj_consume_token(LPAREN);
1854 PrimitiveType();
1855 } else if (jj_2_11(2147483647)) {
1856 jj_consume_token(LPAREN);
1857 AmbiguousName();
1858 jj_consume_token(LBRACKET);
1859 jj_consume_token(RBRACKET);
1860 } else {
1861 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1862 case LPAREN:
1863 jj_consume_token(LPAREN);
1864 AmbiguousName();
1865 jj_consume_token(RPAREN);
1866 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1867 case TILDE:
1868 jj_consume_token(TILDE);
1869 break;
1870 case BANG:
1871 jj_consume_token(BANG);
1872 break;
1873 case LPAREN:
1874 jj_consume_token(LPAREN);
1875 break;
1876 case IDENTIFIER:
1877 jj_consume_token(IDENTIFIER);
1878 break;
1879 case NEW:
1880 jj_consume_token(NEW);
1881 break;
1882 case FALSE:
1883 case NULL:
1884 case TRUE:
1885 case VOID:
1886 case INTEGER_LITERAL:
1887 case FLOATING_POINT_LITERAL:
1888 case CHARACTER_LITERAL:
1889 case STRING_LITERAL:
1890 Literal();
1891 break;
1892 default:
1893 jj_consume_token(-1);
1894 throw new ParseException();
1895 }
1896 break;
1897 default:
1898 jj_consume_token(-1);
1899 throw new ParseException();
1900 }
1901 }
1902 }
1903
1904 final public void PostfixExpression() throws ParseException {
1905 Token t = null;
1906 if (jj_2_12(2147483647)) {
1907 PrimaryExpression();
1908 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1909 case INCR:
1910 t = jj_consume_token(INCR);
1911 break;
1912 case DECR:
1913 t = jj_consume_token(DECR);
1914 break;
1915 default:
1916 jj_consume_token(-1);
1917 throw new ParseException();
1918 }
1919 BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1920 boolean jjtc001 = true;
1921 jjtree.openNodeScope(jjtn001);
1922 jjtreeOpenNodeScope(jjtn001);
1923 try {
1924 jjtree.closeNodeScope(jjtn001, 1);
1925 jjtc001 = false;
1926 jjtreeCloseNodeScope(jjtn001);
1927 jjtn001.kind = t.kind; jjtn001.postfix = true;
1928 } finally {
1929 if (jjtc001) {
1930 jjtree.closeNodeScope(jjtn001, 1);
1931 jjtreeCloseNodeScope(jjtn001);
1932 }
1933 }
1934 } else {
1935 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1936 case BOOLEAN:
1937 case BYTE:
1938 case CHAR:
1939 case DOUBLE:
1940 case FALSE:
1941 case FLOAT:
1942 case INT:
1943 case LONG:
1944 case NEW:
1945 case NULL:
1946 case SHORT:
1947 case TRUE:
1948 case VOID:
1949 case INTEGER_LITERAL:
1950 case FLOATING_POINT_LITERAL:
1951 case CHARACTER_LITERAL:
1952 case STRING_LITERAL:
1953 case IDENTIFIER:
1954 case LPAREN:
1955 PrimaryExpression();
1956 break;
1957 default:
1958 jj_consume_token(-1);
1959 throw new ParseException();
1960 }
1961 }
1962 }
1963
1964 final public void CastExpression() throws ParseException {
1965 /*@bgen(jjtree) CastExpression */
1966 BSHCastExpression jjtn000 = new BSHCastExpression(JJTCASTEXPRESSION);
1967 boolean jjtc000 = true;
1968 jjtree.openNodeScope(jjtn000);
1969 jjtreeOpenNodeScope(jjtn000);
1970 try {
1971 if (jj_2_13(2147483647)) {
1972 jj_consume_token(LPAREN);
1973 Type();
1974 jj_consume_token(RPAREN);
1975 UnaryExpression();
1976 } else {
1977 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1978 case LPAREN:
1979 jj_consume_token(LPAREN);
1980 Type();
1981 jj_consume_token(RPAREN);
1982 UnaryExpressionNotPlusMinus();
1983 break;
1984 default:
1985 jj_consume_token(-1);
1986 throw new ParseException();
1987 }
1988 }
1989 } catch (Throwable jjte000) {
1990 if (jjtc000) {
1991 jjtree.clearNodeScope(jjtn000);
1992 jjtc000 = false;
1993 } else {
1994 jjtree.popNode();
1995 }
1996 if (jjte000 instanceof RuntimeException) {
1997 {if (true) throw (RuntimeException)jjte000;}
1998 }
1999 if (jjte000 instanceof ParseException) {
2000 {if (true) throw (ParseException)jjte000;}
2001 }
2002 {if (true) throw (Error)jjte000;}
2003 } finally {
2004 if (jjtc000) {
2005 jjtree.closeNodeScope(jjtn000, true);
2006 jjtreeCloseNodeScope(jjtn000);
2007 }
2008 }
2009 }
2010
2011 final public void PrimaryExpression() throws ParseException {
2012 /*@bgen(jjtree) PrimaryExpression */
2013 BSHPrimaryExpression jjtn000 = new BSHPrimaryExpression(JJTPRIMARYEXPRESSION);
2014 boolean jjtc000 = true;
2015 jjtree.openNodeScope(jjtn000);
2016 jjtreeOpenNodeScope(jjtn000);
2017 try {
2018 PrimaryPrefix();
2019 label_17:
2020 while (true) {
2021 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2022 case LBRACE:
2023 case LBRACKET:
2024 case DOT:
2025 ;
2026 break;
2027 default:
2028 break label_17;
2029 }
2030 PrimarySuffix();
2031 }
2032 } catch (Throwable jjte000) {
2033 if (jjtc000) {
2034 jjtree.clearNodeScope(jjtn000);
2035 jjtc000 = false;
2036 } else {
2037 jjtree.popNode();
2038 }
2039 if (jjte000 instanceof RuntimeException) {
2040 {if (true) throw (RuntimeException)jjte000;}
2041 }
2042 if (jjte000 instanceof ParseException) {
2043 {if (true) throw (ParseException)jjte000;}
2044 }
2045 {if (true) throw (Error)jjte000;}
2046 } finally {
2047 if (jjtc000) {
2048 jjtree.closeNodeScope(jjtn000, true);
2049 jjtreeCloseNodeScope(jjtn000);
2050 }
2051 }
2052 }
2053
2054 final public void MethodInvocation() throws ParseException {
2055 /*@bgen(jjtree) MethodInvocation */
2056 BSHMethodInvocation jjtn000 = new BSHMethodInvocation(JJTMETHODINVOCATION);
2057 boolean jjtc000 = true;
2058 jjtree.openNodeScope(jjtn000);
2059 jjtreeOpenNodeScope(jjtn000);
2060 try {
2061 AmbiguousName();
2062 Arguments();
2063 } catch (Throwable jjte000) {
2064 if (jjtc000) {
2065 jjtree.clearNodeScope(jjtn000);
2066 jjtc000 = false;
2067 } else {
2068 jjtree.popNode();
2069 }
2070 if (jjte000 instanceof RuntimeException) {
2071 {if (true) throw (RuntimeException)jjte000;}
2072 }
2073 if (jjte000 instanceof ParseException) {
2074 {if (true) throw (ParseException)jjte000;}
2075 }
2076 {if (true) throw (Error)jjte000;}
2077 } finally {
2078 if (jjtc000) {
2079 jjtree.closeNodeScope(jjtn000, true);
2080 jjtreeCloseNodeScope(jjtn000);
2081 }
2082 }
2083 }
2084
2085 final public void PrimaryPrefix() throws ParseException {
2086 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2087 case FALSE:
2088 case NULL:
2089 case TRUE:
2090 case VOID:
2091 case INTEGER_LITERAL:
2092 case FLOATING_POINT_LITERAL:
2093 case CHARACTER_LITERAL:
2094 case STRING_LITERAL:
2095 Literal();
2096 break;
2097 case LPAREN:
2098 jj_consume_token(LPAREN);
2099 Expression();
2100 jj_consume_token(RPAREN);
2101 break;
2102 case NEW:
2103 AllocationExpression();
2104 break;
2105 default:
2106 if (jj_2_14(2147483647)) {
2107 MethodInvocation();
2108 } else if (jj_2_15(2147483647)) {
2109 Type();
2110 } else {
2111 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2112 case IDENTIFIER:
2113 AmbiguousName();
2114 break;
2115 default:
2116 jj_consume_token(-1);
2117 throw new ParseException();
2118 }
2119 }
2120 }
2121 }
2122
2123 final public void PrimarySuffix() throws ParseException {
2124 /*@bgen(jjtree) PrimarySuffix */
2125 BSHPrimarySuffix jjtn000 = new BSHPrimarySuffix(JJTPRIMARYSUFFIX);
2126 boolean jjtc000 = true;
2127 jjtree.openNodeScope(jjtn000);
2128 jjtreeOpenNodeScope(jjtn000);Token t = null;
2129 try {
2130 if (jj_2_16(2)) {
2131 jj_consume_token(DOT);
2132 jj_consume_token(CLASS);
2133 jjtree.closeNodeScope(jjtn000, true);
2134 jjtc000 = false;
2135 jjtreeCloseNodeScope(jjtn000);
2136 jjtn000.operation = BSHPrimarySuffix.CLASS;
2137 } else {
2138 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2139 case LBRACKET:
2140 jj_consume_token(LBRACKET);
2141 Expression();
2142 jj_consume_token(RBRACKET);
2143 jjtree.closeNodeScope(jjtn000, true);
2144 jjtc000 = false;
2145 jjtreeCloseNodeScope(jjtn000);
2146 jjtn000.operation = BSHPrimarySuffix.INDEX;
2147 break;
2148 case DOT:
2149 jj_consume_token(DOT);
2150 t = jj_consume_token(IDENTIFIER);
2151 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2152 case LPAREN:
2153 Arguments();
2154 break;
2155 default:
2156 ;
2157 }
2158 jjtree.closeNodeScope(jjtn000, true);
2159 jjtc000 = false;
2160 jjtreeCloseNodeScope(jjtn000);
2161 jjtn000.operation = BSHPrimarySuffix.NAME;
2162 jjtn000.field = t.image;
2163 break;
2164 case LBRACE:
2165 jj_consume_token(LBRACE);
2166 Expression();
2167 jj_consume_token(RBRACE);
2168 jjtree.closeNodeScope(jjtn000, true);
2169 jjtc000 = false;
2170 jjtreeCloseNodeScope(jjtn000);
2171 jjtn000.operation = BSHPrimarySuffix.PROPERTY;
2172 break;
2173 default:
2174 jj_consume_token(-1);
2175 throw new ParseException();
2176 }
2177 }
2178 } catch (Throwable jjte000) {
2179 if (jjtc000) {
2180 jjtree.clearNodeScope(jjtn000);
2181 jjtc000 = false;
2182 } else {
2183 jjtree.popNode();
2184 }
2185 if (jjte000 instanceof RuntimeException) {
2186 {if (true) throw (RuntimeException)jjte000;}
2187 }
2188 if (jjte000 instanceof ParseException) {
2189 {if (true) throw (ParseException)jjte000;}
2190 }
2191 {if (true) throw (Error)jjte000;}
2192 } finally {
2193 if (jjtc000) {
2194 jjtree.closeNodeScope(jjtn000, true);
2195 jjtreeCloseNodeScope(jjtn000);
2196 }
2197 }
2198 }
2199
2200 final public void Literal() throws ParseException {
2201 /*@bgen(jjtree) Literal */
2202 BSHLiteral jjtn000 = new BSHLiteral(JJTLITERAL);
2203 boolean jjtc000 = true;
2204 jjtree.openNodeScope(jjtn000);
2205 jjtreeOpenNodeScope(jjtn000);Token x;
2206 boolean b;
2207 String literal;
2208 char ch;
2209 try {
2210 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2211 case INTEGER_LITERAL:
2212 x = jj_consume_token(INTEGER_LITERAL);
2213 jjtree.closeNodeScope(jjtn000, true);
2214 jjtc000 = false;
2215 jjtreeCloseNodeScope(jjtn000);
2216 literal = x.image;
2217 ch = literal.charAt(literal.length()-1);
2218 if(ch == 'l' || ch == 'L')
2219 {
2220 literal = literal.substring(0,literal.length()-1);
2221
2222 // This really should be Long.decode, but there isn't one. As a result,
2223 // hex and octal literals ending in 'l' or 'L' don't work.
2224 jjtn000.value = new Primitive( new Long( literal ).longValue() );
2225 }
2226 else
2227 try {
2228 jjtn000.value = new Primitive(
2229 Integer.decode( literal ).intValue() );
2230 } catch ( NumberFormatException e ) {
2231 {if (true) throw createParseException(
2232 "Error or number too big for integer type: "+ literal );}
2233 }
2234 break;
2235 case FLOATING_POINT_LITERAL:
2236 x = jj_consume_token(FLOATING_POINT_LITERAL);
2237 jjtree.closeNodeScope(jjtn000, true);
2238 jjtc000 = false;
2239 jjtreeCloseNodeScope(jjtn000);
2240 literal = x.image;
2241 ch = literal.charAt(literal.length()-1);
2242 if(ch == 'f' || ch == 'F')
2243 {
2244 literal = literal.substring(0,literal.length()-1);
2245 jjtn000.value = new Primitive( new Float( literal ).floatValue() );
2246 }
2247 else
2248 {
2249 if(ch == 'd' || ch == 'D')
2250 literal = literal.substring(0,literal.length()-1);
2251
2252 jjtn000.value = new Primitive( new Double( literal ).doubleValue() );
2253 }
2254 break;
2255 case CHARACTER_LITERAL:
2256 x = jj_consume_token(CHARACTER_LITERAL);
2257 jjtree.closeNodeScope(jjtn000, true);
2258 jjtc000 = false;
2259 jjtreeCloseNodeScope(jjtn000);
2260 try {
2261 jjtn000.charSetup( x.image.substring(1, x.image.length() - 1) );
2262 } catch ( Exception e ) {
2263 {if (true) throw createParseException("Error parsing character: "+x.image);}
2264 }
2265 break;
2266 case STRING_LITERAL:
2267 x = jj_consume_token(STRING_LITERAL);
2268 jjtree.closeNodeScope(jjtn000, true);
2269 jjtc000 = false;
2270 jjtreeCloseNodeScope(jjtn000);
2271 try {
2272 jjtn000.stringSetup( x.image.substring(1, x.image.length() - 1) );
2273 } catch ( Exception e ) {
2274 {if (true) throw createParseException("Error parsing string: "+x.image);}
2275 }
2276 break;
2277 case FALSE:
2278 case TRUE:
2279 b = BooleanLiteral();
2280 jjtree.closeNodeScope(jjtn000, true);
2281 jjtc000 = false;
2282 jjtreeCloseNodeScope(jjtn000);
2283 jjtn000.value = new Primitive( b );
2284 break;
2285 case NULL:
2286 NullLiteral();
2287 jjtree.closeNodeScope(jjtn000, true);
2288 jjtc000 = false;
2289 jjtreeCloseNodeScope(jjtn000);
2290 jjtn000.value = Primitive.NULL;
2291 break;
2292 case VOID:
2293 VoidLiteral();
2294 jjtree.closeNodeScope(jjtn000, true);
2295 jjtc000 = false;
2296 jjtreeCloseNodeScope(jjtn000);
2297 jjtn000.value = Primitive.VOID;
2298 break;
2299 default:
2300 jj_consume_token(-1);
2301 throw new ParseException();
2302 }
2303 } catch (Throwable jjte000) {
2304 if (jjtc000) {
2305 jjtree.clearNodeScope(jjtn000);
2306 jjtc000 = false;
2307 } else {
2308 jjtree.popNode();
2309 }
2310 if (jjte000 instanceof RuntimeException) {
2311 {if (true) throw (RuntimeException)jjte000;}
2312 }
2313 if (jjte000 instanceof ParseException) {
2314 {if (true) throw (ParseException)jjte000;}
2315 }
2316 {if (true) throw (Error)jjte000;}
2317 } finally {
2318 if (jjtc000) {
2319 jjtree.closeNodeScope(jjtn000, true);
2320 jjtreeCloseNodeScope(jjtn000);
2321 }
2322 }
2323 }
2324
2325 final public boolean BooleanLiteral() throws ParseException {
2326 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2327 case TRUE:
2328 jj_consume_token(TRUE);
2329 {if (true) return true;}
2330 break;
2331 case FALSE:
2332 jj_consume_token(FALSE);
2333 {if (true) return false;}
2334 break;
2335 default:
2336 jj_consume_token(-1);
2337 throw new ParseException();
2338 }
2339 throw new Error("Missing return statement in function");
2340 }
2341
2342 final public void NullLiteral() throws ParseException {
2343 jj_consume_token(NULL);
2344 }
2345
2346 final public void VoidLiteral() throws ParseException {
2347 jj_consume_token(VOID);
2348 }
2349
2350 final public void Arguments() throws ParseException {
2351 /*@bgen(jjtree) Arguments */
2352 BSHArguments jjtn000 = new BSHArguments(JJTARGUMENTS);
2353 boolean jjtc000 = true;
2354 jjtree.openNodeScope(jjtn000);
2355 jjtreeOpenNodeScope(jjtn000);
2356 try {
2357 jj_consume_token(LPAREN);
2358 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2359 case BOOLEAN:
2360 case BYTE:
2361 case CHAR:
2362 case DOUBLE:
2363 case FALSE:
2364 case FLOAT:
2365 case INT:
2366 case LONG:
2367 case NEW:
2368 case NULL:
2369 case SHORT:
2370 case TRUE:
2371 case VOID:
2372 case INTEGER_LITERAL:
2373 case FLOATING_POINT_LITERAL:
2374 case CHARACTER_LITERAL:
2375 case STRING_LITERAL:
2376 case IDENTIFIER:
2377 case LPAREN:
2378 case BANG:
2379 case TILDE:
2380 case INCR:
2381 case DECR:
2382 case PLUS:
2383 case MINUS:
2384 ArgumentList();
2385 break;
2386 default:
2387 ;
2388 }
2389 jj_consume_token(RPAREN);
2390 } catch (Throwable jjte000) {
2391 if (jjtc000) {
2392 jjtree.clearNodeScope(jjtn000);
2393 jjtc000 = false;
2394 } else {
2395 jjtree.popNode();
2396 }
2397 if (jjte000 instanceof RuntimeException) {
2398 {if (true) throw (RuntimeException)jjte000;}
2399 }
2400 if (jjte000 instanceof ParseException) {
2401 {if (true) throw (ParseException)jjte000;}
2402 }
2403 {if (true) throw (Error)jjte000;}
2404 } finally {
2405 if (jjtc000) {
2406 jjtree.closeNodeScope(jjtn000, true);
2407 jjtreeCloseNodeScope(jjtn000);
2408 }
2409 }
2410 }
2411
2412 // leave these on the stack for Arguments() to handle
2413 final public void ArgumentList() throws ParseException {
2414 Expression();
2415 label_18:
2416 while (true) {
2417 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2418 case COMMA:
2419 ;
2420 break;
2421 default:
2422 break label_18;
2423 }
2424 jj_consume_token(COMMA);
2425 Expression();
2426 }
2427 }
2428
2429 final public void AllocationExpression() throws ParseException {
2430 /*@bgen(jjtree) AllocationExpression */
2431 BSHAllocationExpression jjtn000 = new BSHAllocationExpression(JJTALLOCATIONEXPRESSION);
2432 boolean jjtc000 = true;
2433 jjtree.openNodeScope(jjtn000);
2434 jjtreeOpenNodeScope(jjtn000);
2435 try {
2436 if (jj_2_18(2)) {
2437 jj_consume_token(NEW);
2438 PrimitiveType();
2439 ArrayDimensions();
2440 } else {
2441 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2442 case NEW:
2443 jj_consume_token(NEW);
2444 AmbiguousName();
2445 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2446 case LBRACKET:
2447 ArrayDimensions();
2448 break;
2449 case LPAREN:
2450 Arguments();
2451 if (jj_2_17(2)) {
2452 Block();
2453 } else {
2454 ;
2455 }
2456 break;
2457 default:
2458 jj_consume_token(-1);
2459 throw new ParseException();
2460 }
2461 break;
2462 default:
2463 jj_consume_token(-1);
2464 throw new ParseException();
2465 }
2466 }
2467 } catch (Throwable jjte000) {
2468 if (jjtc000) {
2469 jjtree.clearNodeScope(jjtn000);
2470 jjtc000 = false;
2471 } else {
2472 jjtree.popNode();
2473 }
2474 if (jjte000 instanceof RuntimeException) {
2475 {if (true) throw (RuntimeException)jjte000;}
2476 }
2477 if (jjte000 instanceof ParseException) {
2478 {if (true) throw (ParseException)jjte000;}
2479 }
2480 {if (true) throw (Error)jjte000;}
2481 } finally {
2482 if (jjtc000) {
2483 jjtree.closeNodeScope(jjtn000, true);
2484 jjtreeCloseNodeScope(jjtn000);
2485 }
2486 }
2487 }
2488
2489 final public void ArrayDimensions() throws ParseException {
2490 /*@bgen(jjtree) ArrayDimensions */
2491 BSHArrayDimensions jjtn000 = new BSHArrayDimensions(JJTARRAYDIMENSIONS);
2492 boolean jjtc000 = true;
2493 jjtree.openNodeScope(jjtn000);
2494 jjtreeOpenNodeScope(jjtn000);
2495 try {
2496 if (jj_2_21(2)) {
2497 label_19:
2498 while (true) {
2499 jj_consume_token(LBRACKET);
2500 Expression();
2501 jj_consume_token(RBRACKET);
2502 jjtn000.addDefinedDimension();
2503 if (jj_2_19(2)) {
2504 ;
2505 } else {
2506 break label_19;
2507 }
2508 }
2509 label_20:
2510 while (true) {
2511 if (jj_2_20(2)) {
2512 ;
2513 } else {
2514 break label_20;
2515 }
2516 jj_consume_token(LBRACKET);
2517 jj_consume_token(RBRACKET);
2518 jjtn000.addUndefinedDimension();
2519 }
2520 } else {
2521 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2522 case LBRACKET:
2523 label_21:
2524 while (true) {
2525 jj_consume_token(LBRACKET);
2526 jj_consume_token(RBRACKET);
2527 jjtn000.addUndefinedDimension();
2528 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2529 case LBRACKET:
2530 ;
2531 break;
2532 default:
2533 break label_21;
2534 }
2535 }
2536 ArrayInitializer();
2537 break;
2538 default:
2539 jj_consume_token(-1);
2540 throw new ParseException();
2541 }
2542 }
2543 } catch (Throwable jjte000) {
2544 if (jjtc000) {
2545 jjtree.clearNodeScope(jjtn000);
2546 jjtc000 = false;
2547 } else {
2548 jjtree.popNode();
2549 }
2550 if (jjte000 instanceof RuntimeException) {
2551 {if (true) throw (RuntimeException)jjte000;}
2552 }
2553 if (jjte000 instanceof ParseException) {
2554 {if (true) throw (ParseException)jjte000;}
2555 }
2556 {if (true) throw (Error)jjte000;}
2557 } finally {
2558 if (jjtc000) {
2559 jjtree.closeNodeScope(jjtn000, true);
2560 jjtreeCloseNodeScope(jjtn000);
2561 }
2562 }
2563 }
2564
2565 /*
2566 * Statement syntax follows.
2567 */
2568 final public void Statement() throws ParseException {
2569 if (jj_2_22(2)) {
2570 LabeledStatement();
2571 } else {
2572 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2573 case LBRACE:
2574 Block();
2575 break;
2576 case SEMICOLON:
2577 EmptyStatement();
2578 break;
2579 case BOOLEAN:
2580 case BYTE:
2581 case CHAR:
2582 case DOUBLE:
2583 case FALSE:
2584 case FLOAT:
2585 case INT:
2586 case LONG:
2587 case NEW:
2588 case NULL:
2589 case SHORT:
2590 case TRUE:
2591 case VOID:
2592 case INTEGER_LITERAL:
2593 case FLOATING_POINT_LITERAL:
2594 case CHARACTER_LITERAL:
2595 case STRING_LITERAL:
2596 case IDENTIFIER:
2597 case LPAREN:
2598 case BANG:
2599 case TILDE:
2600 case INCR:
2601 case DECR:
2602 case PLUS:
2603 case MINUS:
2604 StatementExpression();
2605 jj_consume_token(SEMICOLON);
2606 break;
2607 case SWITCH:
2608 SwitchStatement();
2609 break;
2610 case IF:
2611 IfStatement();
2612 break;
2613 case WHILE:
2614 WhileStatement();
2615 break;
2616 case DO:
2617 DoStatement();
2618 break;
2619 default:
2620 if (isRegularForStatement()) {
2621 ForStatement();
2622 } else {
2623 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2624 case FOR:
2625 EnhancedForStatement();
2626 break;
2627 case BREAK:
2628 BreakStatement();
2629 break;
2630 case CONTINUE:
2631 ContinueStatement();
2632 break;
2633 case RETURN:
2634 ReturnStatement();
2635 break;
2636 case SYNCHRONIZED:
2637 SynchronizedStatement();
2638 break;
2639 case THROW:
2640 ThrowStatement();
2641 break;
2642 case TRY:
2643 TryStatement();
2644 break;
2645 default:
2646 jj_consume_token(-1);
2647 throw new ParseException();
2648 }
2649 }
2650 }
2651 }
2652 }
2653
2654 final public void LabeledStatement() throws ParseException {
2655 jj_consume_token(IDENTIFIER);
2656 jj_consume_token(COLON);
2657 Statement();
2658 }
2659
2660 final public void Block() throws ParseException {
2661 /*@bgen(jjtree) Block */
2662 BSHBlock jjtn000 = new BSHBlock(JJTBLOCK);
2663 boolean jjtc000 = true;
2664 jjtree.openNodeScope(jjtn000);
2665 jjtreeOpenNodeScope(jjtn000);
2666 try {
2667 jj_consume_token(LBRACE);
2668 label_22:
2669 while (true) {
2670 if (jj_2_23(1)) {
2671 ;
2672 } else {
2673 break label_22;
2674 }
2675 BlockStatement();
2676 }
2677 jj_consume_token(RBRACE);
2678 } catch (Throwable jjte000) {
2679 if (jjtc000) {
2680 jjtree.clearNodeScope(jjtn000);
2681 jjtc000 = false;
2682 } else {
2683 jjtree.popNode();
2684 }
2685 if (jjte000 instanceof RuntimeException) {
2686 {if (true) throw (RuntimeException)jjte000;}
2687 }
2688 if (jjte000 instanceof ParseException) {
2689 {if (true) throw (ParseException)jjte000;}
2690 }
2691 {if (true) throw (Error)jjte000;}
2692 } finally {
2693 if (jjtc000) {
2694 jjtree.closeNodeScope(jjtn000, true);
2695 jjtreeCloseNodeScope(jjtn000);
2696 }
2697 }
2698 }
2699
2700 final public void BlockStatement() throws ParseException {
2701 if (jj_2_24(2147483647)) {
2702 ClassDeclaration();
2703 } else if (jj_2_25(2147483647)) {
2704 MethodDeclaration();
2705 } else if (jj_2_26(2147483647)) {
2706 MethodDeclaration();
2707 } else if (jj_2_27(2147483647)) {
2708 TypedVariableDeclaration();
2709 jj_consume_token(SEMICOLON);
2710 } else if (jj_2_28(1)) {
2711 Statement();
2712 } else {
2713 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2714 case IMPORT:
2715 case STATIC:
2716 ImportDeclaration();
2717 break;
2718 case PACKAGE:
2719 PackageDeclaration();
2720 break;
2721 case FORMAL_COMMENT:
2722 FormalComment();
2723 break;
2724 default:
2725 jj_consume_token(-1);
2726 throw new ParseException();
2727 }
2728 }
2729 }
2730
2731 final public void FormalComment() throws ParseException {
2732 /*@bgen(jjtree) #FormalComment( retainComments) */
2733 BSHFormalComment jjtn000 = new BSHFormalComment(JJTFORMALCOMMENT);
2734 boolean jjtc000 = true;
2735 jjtree.openNodeScope(jjtn000);
2736 jjtreeOpenNodeScope(jjtn000);Token t;
2737 try {
2738 t = jj_consume_token(FORMAL_COMMENT);
2739 jjtree.closeNodeScope(jjtn000, retainComments);
2740 jjtc000 = false;
2741 jjtreeCloseNodeScope(jjtn000);
2742 jjtn000.text=t.image;
2743 } finally {
2744 if (jjtc000) {
2745 jjtree.closeNodeScope(jjtn000, retainComments);
2746 jjtreeCloseNodeScope(jjtn000);
2747 }
2748 }
2749 }
2750
2751 final public void EmptyStatement() throws ParseException {
2752 jj_consume_token(SEMICOLON);
2753 }
2754
2755 final public void StatementExpression() throws ParseException {
2756 Expression();
2757 }
2758
2759 final public void SwitchStatement() throws ParseException {
2760 /*@bgen(jjtree) SwitchStatement */
2761 BSHSwitchStatement jjtn000 = new BSHSwitchStatement(JJTSWITCHSTATEMENT);
2762 boolean jjtc000 = true;
2763 jjtree.openNodeScope(jjtn000);
2764 jjtreeOpenNodeScope(jjtn000);
2765 try {
2766 jj_consume_token(SWITCH);
2767 jj_consume_token(LPAREN);
2768 Expression();
2769 jj_consume_token(RPAREN);
2770 jj_consume_token(LBRACE);
2771 label_23:
2772 while (true) {
2773 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2774 case CASE:
2775 case _DEFAULT:
2776 ;
2777 break;
2778 default:
2779 break label_23;
2780 }
2781 SwitchLabel();
2782 label_24:
2783 while (true) {
2784 if (jj_2_29(1)) {
2785 ;
2786 } else {
2787 break label_24;
2788 }
2789 BlockStatement();
2790 }
2791 }
2792 jj_consume_token(RBRACE);
2793 } catch (Throwable jjte000) {
2794 if (jjtc000) {
2795 jjtree.clearNodeScope(jjtn000);
2796 jjtc000 = false;
2797 } else {
2798 jjtree.popNode();
2799 }
2800 if (jjte000 instanceof RuntimeException) {
2801 {if (true) throw (RuntimeException)jjte000;}
2802 }
2803 if (jjte000 instanceof ParseException) {
2804 {if (true) throw (ParseException)jjte000;}
2805 }
2806 {if (true) throw (Error)jjte000;}
2807 } finally {
2808 if (jjtc000) {
2809 jjtree.closeNodeScope(jjtn000, true);
2810 jjtreeCloseNodeScope(jjtn000);
2811 }
2812 }
2813 }
2814
2815 final public void SwitchLabel() throws ParseException {
2816 /*@bgen(jjtree) SwitchLabel */
2817 BSHSwitchLabel jjtn000 = new BSHSwitchLabel(JJTSWITCHLABEL);
2818 boolean jjtc000 = true;
2819 jjtree.openNodeScope(jjtn000);
2820 jjtreeOpenNodeScope(jjtn000);
2821 try {
2822 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2823 case CASE:
2824 jj_consume_token(CASE);
2825 Expression();
2826 jj_consume_token(COLON);
2827 break;
2828 case _DEFAULT:
2829 jj_consume_token(_DEFAULT);
2830 jj_consume_token(COLON);
2831 jjtree.closeNodeScope(jjtn000, true);
2832 jjtc000 = false;
2833 jjtreeCloseNodeScope(jjtn000);
2834 jjtn000.isDefault = true;
2835 break;
2836 default:
2837 jj_consume_token(-1);
2838 throw new ParseException();
2839 }
2840 } catch (Throwable jjte000) {
2841 if (jjtc000) {
2842 jjtree.clearNodeScope(jjtn000);
2843 jjtc000 = false;
2844 } else {
2845 jjtree.popNode();
2846 }
2847 if (jjte000 instanceof RuntimeException) {
2848 {if (true) throw (RuntimeException)jjte000;}
2849 }
2850 if (jjte000 instanceof ParseException) {
2851 {if (true) throw (ParseException)jjte000;}
2852 }
2853 {if (true) throw (Error)jjte000;}
2854 } finally {
2855 if (jjtc000) {
2856 jjtree.closeNodeScope(jjtn000, true);
2857 jjtreeCloseNodeScope(jjtn000);
2858 }
2859 }
2860 }
2861
2862 final public void IfStatement() throws ParseException {
2863 /*@bgen(jjtree) IfStatement */
2864 BSHIfStatement jjtn000 = new BSHIfStatement(JJTIFSTATEMENT);
2865 boolean jjtc000 = true;
2866 jjtree.openNodeScope(jjtn000);
2867 jjtreeOpenNodeScope(jjtn000);
2868 try {
2869 jj_consume_token(IF);
2870 jj_consume_token(LPAREN);
2871 Expression();
2872 jj_consume_token(RPAREN);
2873 Statement();
2874 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2875 case ELSE:
2876 jj_consume_token(ELSE);
2877 Statement();
2878 break;
2879 default:
2880 ;
2881 }
2882 } catch (Throwable jjte000) {
2883 if (jjtc000) {
2884 jjtree.clearNodeScope(jjtn000);
2885 jjtc000 = false;
2886 } else {
2887 jjtree.popNode();
2888 }
2889 if (jjte000 instanceof RuntimeException) {
2890 {if (true) throw (RuntimeException)jjte000;}
2891 }
2892 if (jjte000 instanceof ParseException) {
2893 {if (true) throw (ParseException)jjte000;}
2894 }
2895 {if (true) throw (Error)jjte000;}
2896 } finally {
2897 if (jjtc000) {
2898 jjtree.closeNodeScope(jjtn000, true);
2899 jjtreeCloseNodeScope(jjtn000);
2900 }
2901 }
2902 }
2903
2904 final public void WhileStatement() throws ParseException {
2905 /*@bgen(jjtree) WhileStatement */
2906 BSHWhileStatement jjtn000 = new BSHWhileStatement(JJTWHILESTATEMENT);
2907 boolean jjtc000 = true;
2908 jjtree.openNodeScope(jjtn000);
2909 jjtreeOpenNodeScope(jjtn000);
2910 try {
2911 jj_consume_token(WHILE);
2912 jj_consume_token(LPAREN);
2913 Expression();
2914 jj_consume_token(RPAREN);
2915 Statement();
2916 } catch (Throwable jjte000) {
2917 if (jjtc000) {
2918 jjtree.clearNodeScope(jjtn000);
2919 jjtc000 = false;
2920 } else {
2921 jjtree.popNode();
2922 }
2923 if (jjte000 instanceof RuntimeException) {
2924 {if (true) throw (RuntimeException)jjte000;}
2925 }
2926 if (jjte000 instanceof ParseException) {
2927 {if (true) throw (ParseException)jjte000;}
2928 }
2929 {if (true) throw (Error)jjte000;}
2930 } finally {
2931 if (jjtc000) {
2932 jjtree.closeNodeScope(jjtn000, true);
2933 jjtreeCloseNodeScope(jjtn000);
2934 }
2935 }
2936 }
2937
2938 /*
2939 Do statement is just a While statement with a special hook to execute
2940 at least once.
2941 */
2942 final public void DoStatement() throws ParseException {
2943 /*@bgen(jjtree) WhileStatement */
2944 BSHWhileStatement jjtn000 = new BSHWhileStatement(JJTWHILESTATEMENT);
2945 boolean jjtc000 = true;
2946 jjtree.openNodeScope(jjtn000);
2947 jjtreeOpenNodeScope(jjtn000);
2948 try {
2949 jj_consume_token(DO);
2950 Statement();
2951 jj_consume_token(WHILE);
2952 jj_consume_token(LPAREN);
2953 Expression();
2954 jj_consume_token(RPAREN);
2955 jj_consume_token(SEMICOLON);
2956 jjtree.closeNodeScope(jjtn000, true);
2957 jjtc000 = false;
2958 jjtreeCloseNodeScope(jjtn000);
2959 jjtn000.isDoStatement=true;
2960 } catch (Throwable jjte000) {
2961 if (jjtc000) {
2962 jjtree.clearNodeScope(jjtn000);
2963 jjtc000 = false;
2964 } else {
2965 jjtree.popNode();
2966 }
2967 if (jjte000 instanceof RuntimeException) {
2968 {if (true) throw (RuntimeException)jjte000;}
2969 }
2970 if (jjte000 instanceof ParseException) {
2971 {if (true) throw (ParseException)jjte000;}
2972 }
2973 {if (true) throw (Error)jjte000;}
2974 } finally {
2975 if (jjtc000) {
2976 jjtree.closeNodeScope(jjtn000, true);
2977 jjtreeCloseNodeScope(jjtn000);
2978 }
2979 }
2980 }
2981
2982 final public void ForStatement() throws ParseException {
2983 /*@bgen(jjtree) ForStatement */
2984 BSHForStatement jjtn000 = new BSHForStatement(JJTFORSTATEMENT);
2985 boolean jjtc000 = true;
2986 jjtree.openNodeScope(jjtn000);
2987 jjtreeOpenNodeScope(jjtn000);Token t = null;
2988 try {
2989 jj_consume_token(FOR);
2990 jj_consume_token(LPAREN);
2991 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2992 case ABSTRACT:
2993 case BOOLEAN:
2994 case BYTE:
2995 case CHAR:
2996 case DOUBLE:
2997 case FALSE:
2998 case FINAL:
2999 case FLOAT:
3000 case INT:
3001 case LONG:
3002 case NATIVE:
3003 case NEW:
3004 case NULL:
3005 case PRIVATE:
3006 case PROTECTED:
3007 case PUBLIC:
3008 case SHORT:
3009 case STATIC:
3010 case STRICTFP:
3011 case SYNCHRONIZED:
3012 case TRANSIENT:
3013 case TRUE:
3014 case VOID:
3015 case VOLATILE:
3016 case INTEGER_LITERAL:
3017 case FLOATING_POINT_LITERAL:
3018 case CHARACTER_LITERAL:
3019 case STRING_LITERAL:
3020 case IDENTIFIER:
3021 case LPAREN:
3022 case BANG:
3023 case TILDE:
3024 case INCR:
3025 case DECR:
3026 case PLUS:
3027 case MINUS:
3028 ForInit();
3029 jjtn000.hasForInit=true;
3030 break;
3031 default:
3032 ;
3033 }
3034 jj_consume_token(SEMICOLON);
3035 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3036 case BOOLEAN:
3037 case BYTE:
3038 case CHAR:
3039 case DOUBLE:
3040 case FALSE:
3041 case FLOAT:
3042 case INT:
3043 case LONG:
3044 case NEW:
3045 case NULL:
3046 case SHORT:
3047 case TRUE:
3048 case VOID:
3049 case INTEGER_LITERAL:
3050 case FLOATING_POINT_LITERAL:
3051 case CHARACTER_LITERAL:
3052 case STRING_LITERAL:
3053 case IDENTIFIER:
3054 case LPAREN:
3055 case BANG:
3056 case TILDE:
3057 case INCR:
3058 case DECR:
3059 case PLUS:
3060 case MINUS:
3061 Expression();
3062 jjtn000.hasExpression=true;
3063 break;
3064 default:
3065 ;
3066 }
3067 jj_consume_token(SEMICOLON);
3068 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3069 case BOOLEAN:
3070 case BYTE:
3071 case CHAR:
3072 case DOUBLE:
3073 case FALSE:
3074 case FLOAT:
3075 case INT:
3076 case LONG:
3077 case NEW:
3078 case NULL:
3079 case SHORT:
3080 case TRUE:
3081 case VOID:
3082 case INTEGER_LITERAL:
3083 case FLOATING_POINT_LITERAL:
3084 case CHARACTER_LITERAL:
3085 case STRING_LITERAL:
3086 case IDENTIFIER:
3087 case LPAREN:
3088 case BANG:
3089 case TILDE:
3090 case INCR:
3091 case DECR:
3092 case PLUS:
3093 case MINUS:
3094 ForUpdate();
3095 jjtn000.hasForUpdate=true;
3096 break;
3097 default:
3098 ;
3099 }
3100 jj_consume_token(RPAREN);
3101 Statement();
3102 } catch (Throwable jjte000) {
3103 if (jjtc000) {
3104 jjtree.clearNodeScope(jjtn000);
3105 jjtc000 = false;
3106 } else {
3107 jjtree.popNode();
3108 }
3109 if (jjte000 instanceof RuntimeException) {
3110 {if (true) throw (RuntimeException)jjte000;}
3111 }
3112 if (jjte000 instanceof ParseException) {
3113 {if (true) throw (ParseException)jjte000;}
3114 }
3115 {if (true) throw (Error)jjte000;}
3116 } finally {
3117 if (jjtc000) {
3118 jjtree.closeNodeScope(jjtn000, true);
3119 jjtreeCloseNodeScope(jjtn000);
3120 }
3121 }
3122 }
3123
3124 /*
3125 The new JDK1.5 enhanced for statement.
3126 e.g. for( int a : arrayOfInts ) { }
3127 We also support loose typing of the iterator var for BeanShell
3128 e.g. for( a : arrayOfInts ) { }
3129 */
3130 final public void EnhancedForStatement() throws ParseException {
3131 /*@bgen(jjtree) EnhancedForStatement */
3132 BSHEnhancedForStatement jjtn000 = new BSHEnhancedForStatement(JJTENHANCEDFORSTATEMENT);
3133 boolean jjtc000 = true;
3134 jjtree.openNodeScope(jjtn000);
3135 jjtreeOpenNodeScope(jjtn000);Token t = null;
3136 try {
3137 if (jj_2_30(4)) {
3138 jj_consume_token(FOR);
3139 jj_consume_token(LPAREN);
3140 t = jj_consume_token(IDENTIFIER);
3141 jj_consume_token(COLON);
3142 Expression();
3143 jj_consume_token(RPAREN);
3144 Statement();
3145 jjtree.closeNodeScope(jjtn000, true);
3146 jjtc000 = false;
3147 jjtreeCloseNodeScope(jjtn000);
3148 jjtn000.varName = t.image;
3149 } else {
3150 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3151 case FOR:
3152 jj_consume_token(FOR);
3153 jj_consume_token(LPAREN);
3154 Type();
3155 t = jj_consume_token(IDENTIFIER);
3156 jj_consume_token(COLON);
3157 Expression();
3158 jj_consume_token(RPAREN);
3159 Statement();
3160 jjtree.closeNodeScope(jjtn000, true);
3161 jjtc000 = false;
3162 jjtreeCloseNodeScope(jjtn000);
3163 jjtn000.varName = t.image;
3164 break;
3165 default:
3166 jj_consume_token(-1);
3167 throw new ParseException();
3168 }
3169 }
3170 } catch (Throwable jjte000) {
3171 if (jjtc000) {
3172 jjtree.clearNodeScope(jjtn000);
3173 jjtc000 = false;
3174 } else {
3175 jjtree.popNode();
3176 }
3177 if (jjte000 instanceof RuntimeException) {
3178 {if (true) throw (RuntimeException)jjte000;}
3179 }
3180 if (jjte000 instanceof ParseException) {
3181 {if (true) throw (ParseException)jjte000;}
3182 }
3183 {if (true) throw (Error)jjte000;}
3184 } finally {
3185 if (jjtc000) {
3186 jjtree.closeNodeScope(jjtn000, true);
3187 jjtreeCloseNodeScope(jjtn000);
3188 }
3189 }
3190 }
3191
3192 final public void ForInit() throws ParseException {
3193 Token t = null;
3194 if (jj_2_31(2147483647)) {
3195 TypedVariableDeclaration();
3196 } else {
3197 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3198 case BOOLEAN:
3199 case BYTE:
3200 case CHAR:
3201 case DOUBLE:
3202 case FALSE:
3203 case FLOAT:
3204 case INT:
3205 case LONG:
3206 case NEW:
3207 case NULL:
3208 case SHORT:
3209 case TRUE:
3210 case VOID:
3211 case INTEGER_LITERAL:
3212 case FLOATING_POINT_LITERAL:
3213 case CHARACTER_LITERAL:
3214 case STRING_LITERAL:
3215 case IDENTIFIER:
3216 case LPAREN:
3217 case BANG:
3218 case TILDE:
3219 case INCR:
3220 case DECR:
3221 case PLUS:
3222 case MINUS:
3223 StatementExpressionList();
3224 break;
3225 default:
3226 jj_consume_token(-1);
3227 throw new ParseException();
3228 }
3229 }
3230 }
3231
3232 /**
3233 Declared a typed variable.
3234 Untyped variables are not declared per-se but are handled by the part
3235 of the grammar that deals with assignments.
3236 */
3237 final public void TypedVariableDeclaration() throws ParseException {
3238 /*@bgen(jjtree) TypedVariableDeclaration */
3239 BSHTypedVariableDeclaration jjtn000 = new BSHTypedVariableDeclaration(JJTTYPEDVARIABLEDECLARATION);
3240 boolean jjtc000 = true;
3241 jjtree.openNodeScope(jjtn000);
3242 jjtreeOpenNodeScope(jjtn000);Token t = null;
3243 Modifiers mods;
3244 try {
3245 mods = Modifiers(Modifiers.FIELD, false);
3246 Type();
3247 VariableDeclarator();
3248 label_25:
3249 while (true) {
3250 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3251 case COMMA:
3252 ;
3253 break;
3254 default:
3255 break label_25;
3256 }
3257 jj_consume_token(COMMA);
3258 VariableDeclarator();
3259 }
3260 jjtree.closeNodeScope(jjtn000, true);
3261 jjtc000 = false;
3262 jjtreeCloseNodeScope(jjtn000);
3263 jjtn000.modifiers = mods;
3264 } catch (Throwable jjte000) {
3265 if (jjtc000) {
3266 jjtree.clearNodeScope(jjtn000);
3267 jjtc000 = false;
3268 } else {
3269 jjtree.popNode();
3270 }
3271 if (jjte000 instanceof RuntimeException) {
3272 {if (true) throw (RuntimeException)jjte000;}
3273 }
3274 if (jjte000 instanceof ParseException) {
3275 {if (true) throw (ParseException)jjte000;}
3276 }
3277 {if (true) throw (Error)jjte000;}
3278 } finally {
3279 if (jjtc000) {
3280 jjtree.closeNodeScope(jjtn000, true);
3281 jjtreeCloseNodeScope(jjtn000);
3282 }
3283 }
3284 }
3285
3286 final public void StatementExpressionList() throws ParseException {
3287 /*@bgen(jjtree) StatementExpressionList */
3288 BSHStatementExpressionList jjtn000 = new BSHStatementExpressionList(JJTSTATEMENTEXPRESSIONLIST);
3289 boolean jjtc000 = true;
3290 jjtree.openNodeScope(jjtn000);
3291 jjtreeOpenNodeScope(jjtn000);
3292 try {
3293 StatementExpression();
3294 label_26:
3295 while (true) {
3296 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3297 case COMMA:
3298 ;
3299 break;
3300 default:
3301 break label_26;
3302 }
3303 jj_consume_token(COMMA);
3304 StatementExpression();
3305 }
3306 } catch (Throwable jjte000) {
3307 if (jjtc000) {
3308 jjtree.clearNodeScope(jjtn000);
3309 jjtc000 = false;
3310 } else {
3311 jjtree.popNode();
3312 }
3313 if (jjte000 instanceof RuntimeException) {
3314 {if (true) throw (RuntimeException)jjte000;}
3315 }
3316 if (jjte000 instanceof ParseException) {
3317 {if (true) throw (ParseException)jjte000;}
3318 }
3319 {if (true) throw (Error)jjte000;}
3320 } finally {
3321 if (jjtc000) {
3322 jjtree.closeNodeScope(jjtn000, true);
3323 jjtreeCloseNodeScope(jjtn000);
3324 }
3325 }
3326 }
3327
3328 final public void ForUpdate() throws ParseException {
3329 StatementExpressionList();
3330 }
3331
3332 final public void BreakStatement() throws ParseException {
3333 /*@bgen(jjtree) ReturnStatement */
3334 BSHReturnStatement jjtn000 = new BSHReturnStatement(JJTRETURNSTATEMENT);
3335 boolean jjtc000 = true;
3336 jjtree.openNodeScope(jjtn000);
3337 jjtreeOpenNodeScope(jjtn000);
3338 try {
3339 jj_consume_token(BREAK);
3340 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3341 case IDENTIFIER:
3342 jj_consume_token(IDENTIFIER);
3343 break;
3344 default:
3345 ;
3346 }
3347 jj_consume_token(SEMICOLON);
3348 jjtree.closeNodeScope(jjtn000, true);
3349 jjtc000 = false;
3350 jjtreeCloseNodeScope(jjtn000);
3351 jjtn000.kind = BREAK;
3352 } finally {
3353 if (jjtc000) {
3354 jjtree.closeNodeScope(jjtn000, true);
3355 jjtreeCloseNodeScope(jjtn000);
3356 }
3357 }
3358 }
3359
3360 final public void ContinueStatement() throws ParseException {
3361 /*@bgen(jjtree) ReturnStatement */
3362 BSHReturnStatement jjtn000 = new BSHReturnStatement(JJTRETURNSTATEMENT);
3363 boolean jjtc000 = true;
3364 jjtree.openNodeScope(jjtn000);
3365 jjtreeOpenNodeScope(jjtn000);
3366 try {
3367 jj_consume_token(CONTINUE);
3368 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3369 case IDENTIFIER:
3370 jj_consume_token(IDENTIFIER);
3371 break;
3372 default:
3373 ;
3374 }
3375 jj_consume_token(SEMICOLON);
3376 jjtree.closeNodeScope(jjtn000, true);
3377 jjtc000 = false;
3378 jjtreeCloseNodeScope(jjtn000);
3379 jjtn000.kind = CONTINUE;
3380 } finally {
3381 if (jjtc000) {
3382 jjtree.closeNodeScope(jjtn000, true);
3383 jjtreeCloseNodeScope(jjtn000);
3384 }
3385 }
3386 }
3387
3388 final public void ReturnStatement() throws ParseException {
3389 /*@bgen(jjtree) ReturnStatement */
3390 BSHReturnStatement jjtn000 = new BSHReturnStatement(JJTRETURNSTATEMENT);
3391 boolean jjtc000 = true;
3392 jjtree.openNodeScope(jjtn000);
3393 jjtreeOpenNodeScope(jjtn000);
3394 try {
3395 jj_consume_token(RETURN);
3396 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3397 case BOOLEAN:
3398 case BYTE:
3399 case CHAR:
3400 case DOUBLE:
3401 case FALSE:
3402 case FLOAT:
3403 case INT:
3404 case LONG:
3405 case NEW:
3406 case NULL:
3407 case SHORT:
3408 case TRUE:
3409 case VOID:
3410 case INTEGER_LITERAL:
3411 case FLOATING_POINT_LITERAL:
3412 case CHARACTER_LITERAL:
3413 case STRING_LITERAL:
3414 case IDENTIFIER:
3415 case LPAREN:
3416 case BANG:
3417 case TILDE:
3418 case INCR:
3419 case DECR:
3420 case PLUS:
3421 case MINUS:
3422 Expression();
3423 break;
3424 default:
3425 ;
3426 }
3427 jj_consume_token(SEMICOLON);
3428 jjtree.closeNodeScope(jjtn000, true);
3429 jjtc000 = false;
3430 jjtreeCloseNodeScope(jjtn000);
3431 jjtn000.kind = RETURN;
3432 } catch (Throwable jjte000) {
3433 if (jjtc000) {
3434 jjtree.clearNodeScope(jjtn000);
3435 jjtc000 = false;
3436 } else {
3437 jjtree.popNode();
3438 }
3439 if (jjte000 instanceof RuntimeException) {
3440 {if (true) throw (RuntimeException)jjte000;}
3441 }
3442 if (jjte000 instanceof ParseException) {
3443 {if (true) throw (ParseException)jjte000;}
3444 }
3445 {if (true) throw (Error)jjte000;}
3446 } finally {
3447 if (jjtc000) {
3448 jjtree.closeNodeScope(jjtn000, true);
3449 jjtreeCloseNodeScope(jjtn000);
3450 }
3451 }
3452 }
3453
3454 final public void SynchronizedStatement() throws ParseException {
3455 /*@bgen(jjtree) Block */
3456 BSHBlock jjtn000 = new BSHBlock(JJTBLOCK);
3457 boolean jjtc000 = true;
3458 jjtree.openNodeScope(jjtn000);
3459 jjtreeOpenNodeScope(jjtn000);
3460 try {
3461 jj_consume_token(SYNCHRONIZED);
3462 jj_consume_token(LPAREN);
3463 Expression();
3464 jj_consume_token(RPAREN);
3465 Block();
3466 jjtree.closeNodeScope(jjtn000, true);
3467 jjtc000 = false;
3468 jjtreeCloseNodeScope(jjtn000);
3469 jjtn000.isSynchronized=true;
3470 } catch (Throwable jjte000) {
3471 if (jjtc000) {
3472 jjtree.clearNodeScope(jjtn000);
3473 jjtc000 = false;
3474 } else {
3475 jjtree.popNode();
3476 }
3477 if (jjte000 instanceof RuntimeException) {
3478 {if (true) throw (RuntimeException)jjte000;}
3479 }
3480 if (jjte000 instanceof ParseException) {
3481 {if (true) throw (ParseException)jjte000;}
3482 }
3483 {if (true) throw (Error)jjte000;}
3484 } finally {
3485 if (jjtc000) {
3486 jjtree.closeNodeScope(jjtn000, true);
3487 jjtreeCloseNodeScope(jjtn000);
3488 }
3489 }
3490 }
3491
3492 final public void ThrowStatement() throws ParseException {
3493 /*@bgen(jjtree) ThrowStatement */
3494 BSHThrowStatement jjtn000 = new BSHThrowStatement(JJTTHROWSTATEMENT);
3495 boolean jjtc000 = true;
3496 jjtree.openNodeScope(jjtn000);
3497 jjtreeOpenNodeScope(jjtn000);
3498 try {
3499 jj_consume_token(THROW);
3500 Expression();
3501 jj_consume_token(SEMICOLON);
3502 } catch (Throwable jjte000) {
3503 if (jjtc000) {
3504 jjtree.clearNodeScope(jjtn000);
3505 jjtc000 = false;
3506 } else {
3507 jjtree.popNode();
3508 }
3509 if (jjte000 instanceof RuntimeException) {
3510 {if (true) throw (RuntimeException)jjte000;}
3511 }
3512 if (jjte000 instanceof ParseException) {
3513 {if (true) throw (ParseException)jjte000;}
3514 }
3515 {if (true) throw (Error)jjte000;}
3516 } finally {
3517 if (jjtc000) {
3518 jjtree.closeNodeScope(jjtn000, true);
3519 jjtreeCloseNodeScope(jjtn000);
3520 }
3521 }
3522 }
3523
3524 final public void TryStatement() throws ParseException {
3525 /*@bgen(jjtree) TryStatement */
3526 BSHTryStatement jjtn000 = new BSHTryStatement(JJTTRYSTATEMENT);
3527 boolean jjtc000 = true;
3528 jjtree.openNodeScope(jjtn000);
3529 jjtreeOpenNodeScope(jjtn000);boolean closed = false;
3530 try {
3531 jj_consume_token(TRY);
3532 Block();
3533 label_27:
3534 while (true) {
3535 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3536 case CATCH:
3537 ;
3538 break;
3539 default:
3540 break label_27;
3541 }
3542 jj_consume_token(CATCH);
3543 jj_consume_token(LPAREN);
3544 FormalParameter();
3545 jj_consume_token(RPAREN);
3546 Block();
3547 closed = true;
3548 }
3549 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3550 case FINALLY:
3551 jj_consume_token(FINALLY);
3552 Block();
3553 closed = true;
3554 break;
3555 default:
3556 ;
3557 }
3558 jjtree.closeNodeScope(jjtn000, true);
3559 jjtc000 = false;
3560 jjtreeCloseNodeScope(jjtn000);
3561 if ( !closed ) {if (true) throw generateParseException();}
3562 } catch (Throwable jjte000) {
3563 if (jjtc000) {
3564 jjtree.clearNodeScope(jjtn000);
3565 jjtc000 = false;
3566 } else {
3567 jjtree.popNode();
3568 }
3569 if (jjte000 instanceof RuntimeException) {
3570 {if (true) throw (RuntimeException)jjte000;}
3571 }
3572 if (jjte000 instanceof ParseException) {
3573 {if (true) throw (ParseException)jjte000;}
3574 }
3575 {if (true) throw (Error)jjte000;}
3576 } finally {
3577 if (jjtc000) {
3578 jjtree.closeNodeScope(jjtn000, true);
3579 jjtreeCloseNodeScope(jjtn000);
3580 }
3581 }
3582 }
3583
3584 final private boolean jj_2_1(int xla) {
3585 jj_la = xla; jj_lastpos = jj_scanpos = token;
3586 try { return !jj_3_1(); }
3587 catch(LookaheadSuccess ls) { return true; }
3588 }
3589
3590 final private boolean jj_2_2(int xla) {
3591 jj_la = xla; jj_lastpos = jj_scanpos = token;
3592 try { return !jj_3_2(); }
3593 catch(LookaheadSuccess ls) { return true; }
3594 }
3595
3596 final private boolean jj_2_3(int xla) {
3597 jj_la = xla; jj_lastpos = jj_scanpos = token;
3598 try { return !jj_3_3(); }
3599 catch(LookaheadSuccess ls) { return true; }
3600 }
3601
3602 final private boolean jj_2_4(int xla) {
3603 jj_la = xla; jj_lastpos = jj_scanpos = token;
3604 try { return !jj_3_4(); }
3605 catch(LookaheadSuccess ls) { return true; }
3606 }
3607
3608 final private boolean jj_2_5(int xla) {
3609 jj_la = xla; jj_lastpos = jj_scanpos = token;
3610 try { return !jj_3_5(); }
3611 catch(LookaheadSuccess ls) { return true; }
3612 }
3613
3614 final private boolean jj_2_6(int xla) {
3615 jj_la = xla; jj_lastpos = jj_scanpos = token;
3616 try { return !jj_3_6(); }
3617 catch(LookaheadSuccess ls) { return true; }
3618 }
3619
3620 final private boolean jj_2_7(int xla) {
3621 jj_la = xla; jj_lastpos = jj_scanpos = token;
3622 try { return !jj_3_7(); }
3623 catch(LookaheadSuccess ls) { return true; }
3624 }
3625
3626 final private boolean jj_2_8(int xla) {
3627 jj_la = xla; jj_lastpos = jj_scanpos = token;
3628 try { return !jj_3_8(); }
3629 catch(LookaheadSuccess ls) { return true; }
3630 }
3631
3632 final private boolean jj_2_9(int xla) {
3633 jj_la = xla; jj_lastpos = jj_scanpos = token;
3634 try { return !jj_3_9(); }
3635 catch(LookaheadSuccess ls) { return true; }
3636 }
3637
3638 final private boolean jj_2_10(int xla) {
3639 jj_la = xla; jj_lastpos = jj_scanpos = token;
3640 try { return !jj_3_10(); }
3641 catch(LookaheadSuccess ls) { return true; }
3642 }
3643
3644 final private boolean jj_2_11(int xla) {
3645 jj_la = xla; jj_lastpos = jj_scanpos = token;
3646 try { return !jj_3_11(); }
3647 catch(LookaheadSuccess ls) { return true; }
3648 }
3649
3650 final private boolean jj_2_12(int xla) {
3651 jj_la = xla; jj_lastpos = jj_scanpos = token;
3652 try { return !jj_3_12(); }
3653 catch(LookaheadSuccess ls) { return true; }
3654 }
3655
3656 final private boolean jj_2_13(int xla) {
3657 jj_la = xla; jj_lastpos = jj_scanpos = token;
3658 try { return !jj_3_13(); }
3659 catch(LookaheadSuccess ls) { return true; }
3660 }
3661
3662 final private boolean jj_2_14(int xla) {
3663 jj_la = xla; jj_lastpos = jj_scanpos = token;
3664 try { return !jj_3_14(); }
3665 catch(LookaheadSuccess ls) { return true; }
3666 }
3667
3668 final private boolean jj_2_15(int xla) {
3669 jj_la = xla; jj_lastpos = jj_scanpos = token;
3670 try { return !jj_3_15(); }
3671 catch(LookaheadSuccess ls) { return true; }
3672 }
3673
3674 final private boolean jj_2_16(int xla) {
3675 jj_la = xla; jj_lastpos = jj_scanpos = token;
3676 try { return !jj_3_16(); }
3677 catch(LookaheadSuccess ls) { return true; }
3678 }
3679
3680 final private boolean jj_2_17(int xla) {
3681 jj_la = xla; jj_lastpos = jj_scanpos = token;
3682 try { return !jj_3_17(); }
3683 catch(LookaheadSuccess ls) { return true; }
3684 }
3685
3686 final private boolean jj_2_18(int xla) {
3687 jj_la = xla; jj_lastpos = jj_scanpos = token;
3688 try { return !jj_3_18(); }
3689 catch(LookaheadSuccess ls) { return true; }
3690 }
3691
3692 final private boolean jj_2_19(int xla) {
3693 jj_la = xla; jj_lastpos = jj_scanpos = token;
3694 try { return !jj_3_19(); }
3695 catch(LookaheadSuccess ls) { return true; }
3696 }
3697
3698 final private boolean jj_2_20(int xla) {
3699 jj_la = xla; jj_lastpos = jj_scanpos = token;
3700 try { return !jj_3_20(); }
3701 catch(LookaheadSuccess ls) { return true; }
3702 }
3703
3704 final private boolean jj_2_21(int xla) {
3705 jj_la = xla; jj_lastpos = jj_scanpos = token;
3706 try { return !jj_3_21(); }
3707 catch(LookaheadSuccess ls) { return true; }
3708 }
3709
3710 final private boolean jj_2_22(int xla) {
3711 jj_la = xla; jj_lastpos = jj_scanpos = token;
3712 try { return !jj_3_22(); }
3713 catch(LookaheadSuccess ls) { return true; }
3714 }
3715
3716 final private boolean jj_2_23(int xla) {
3717 jj_la = xla; jj_lastpos = jj_scanpos = token;
3718 try { return !jj_3_23(); }
3719 catch(LookaheadSuccess ls) { return true; }
3720 }
3721
3722 final private boolean jj_2_24(int xla) {
3723 jj_la = xla; jj_lastpos = jj_scanpos = token;
3724 try { return !jj_3_24(); }
3725 catch(LookaheadSuccess ls) { return true; }
3726 }
3727
3728 final private boolean jj_2_25(int xla) {
3729 jj_la = xla; jj_lastpos = jj_scanpos = token;
3730 try { return !jj_3_25(); }
3731 catch(LookaheadSuccess ls) { return true; }
3732 }
3733
3734 final private boolean jj_2_26(int xla) {
3735 jj_la = xla; jj_lastpos = jj_scanpos = token;
3736 try { return !jj_3_26(); }
3737 catch(LookaheadSuccess ls) { return true; }
3738 }
3739
3740 final private boolean jj_2_27(int xla) {
3741 jj_la = xla; jj_lastpos = jj_scanpos = token;
3742 try { return !jj_3_27(); }
3743 catch(LookaheadSuccess ls) { return true; }
3744 }
3745
3746 final private boolean jj_2_28(int xla) {
3747 jj_la = xla; jj_lastpos = jj_scanpos = token;
3748 try { return !jj_3_28(); }
3749 catch(LookaheadSuccess ls) { return true; }
3750 }
3751
3752 final private boolean jj_2_29(int xla) {
3753 jj_la = xla; jj_lastpos = jj_scanpos = token;
3754 try { return !jj_3_29(); }
3755 catch(LookaheadSuccess ls) { return true; }
3756 }
3757
3758 final private boolean jj_2_30(int xla) {
3759 jj_la = xla; jj_lastpos = jj_scanpos = token;
3760 try { return !jj_3_30(); }
3761 catch(LookaheadSuccess ls) { return true; }
3762 }
3763
3764 final private boolean jj_2_31(int xla) {
3765 jj_la = xla; jj_lastpos = jj_scanpos = token;
3766 try { return !jj_3_31(); }
3767 catch(LookaheadSuccess ls) { return true; }
3768 }
3769
3770 final private boolean jj_3R_46() {
3771 if (jj_3R_91()) return true;
3772 return false;
3773 }
3774
3775 final private boolean jj_3R_28() {
3776 Token xsp;
3777 xsp = jj_scanpos;
3778 if (jj_3R_46()) {
3779 jj_scanpos = xsp;
3780 if (jj_3R_47()) {
3781 jj_scanpos = xsp;
3782 if (jj_3R_48()) {
3783 jj_scanpos = xsp;
3784 if (jj_3R_49()) {
3785 jj_scanpos = xsp;
3786 if (jj_3_28()) {
3787 jj_scanpos = xsp;
3788 if (jj_3R_50()) {
3789 jj_scanpos = xsp;
3790 if (jj_3R_51()) {
3791 jj_scanpos = xsp;
3792 if (jj_3R_52()) return true;
3793 }
3794 }
3795 }
3796 }
3797 }
3798 }
3799 }
3800 return false;
3801 }
3802
3803 final private boolean jj_3_23() {
3804 if (jj_3R_28()) return true;
3805 return false;
3806 }
3807
3808 final private boolean jj_3R_161() {
3809 if (jj_3R_164()) return true;
3810 Token xsp;
3811 while (true) {
3812 xsp = jj_scanpos;
3813 if (jj_3R_169()) { jj_scanpos = xsp; break; }
3814 }
3815 return false;
3816 }
3817
3818 final private boolean jj_3R_38() {
3819 if (jj_scan_token(LBRACE)) return true;
3820 Token xsp;
3821 while (true) {
3822 xsp = jj_scanpos;
3823 if (jj_3_23()) { jj_scanpos = xsp; break; }
3824 }
3825 if (jj_scan_token(RBRACE)) return true;
3826 return false;
3827 }
3828
3829 final private boolean jj_3R_158() {
3830 if (jj_3R_161()) return true;
3831 Token xsp;
3832 while (true) {
3833 xsp = jj_scanpos;
3834 if (jj_3R_167()) { jj_scanpos = xsp; break; }
3835 }
3836 return false;
3837 }
3838
3839 final private boolean jj_3R_40() {
3840 if (jj_scan_token(IDENTIFIER)) return true;
3841 if (jj_scan_token(COLON)) return true;
3842 if (jj_3R_45()) return true;
3843 return false;
3844 }
3845
3846 final private boolean jj_3R_156() {
3847 if (jj_scan_token(HOOK)) return true;
3848 if (jj_3R_39()) return true;
3849 if (jj_scan_token(COLON)) return true;
3850 if (jj_3R_108()) return true;
3851 return false;
3852 }
3853
3854 final private boolean jj_3R_165() {
3855 Token xsp;
3856 xsp = jj_scanpos;
3857 if (jj_scan_token(108)) {
3858 jj_scanpos = xsp;
3859 if (jj_scan_token(109)) return true;
3860 }
3861 if (jj_3R_158()) return true;
3862 return false;
3863 }
3864
3865 final private boolean jj_3R_153() {
3866 if (jj_3R_158()) return true;
3867 Token xsp;
3868 while (true) {
3869 xsp = jj_scanpos;
3870 if (jj_3R_165()) { jj_scanpos = xsp; break; }
3871 }
3872 return false;
3873 }
3874
3875 final private boolean jj_3R_90() {
3876 if (jj_3R_124()) return true;
3877 return false;
3878 }
3879
3880 final private boolean jj_3R_89() {
3881 if (jj_3R_123()) return true;
3882 return false;
3883 }
3884
3885 final private boolean jj_3R_88() {
3886 if (jj_3R_122()) return true;
3887 return false;
3888 }
3889
3890 final private boolean jj_3R_162() {
3891 Token xsp;
3892 xsp = jj_scanpos;
3893 if (jj_scan_token(98)) {
3894 jj_scanpos = xsp;
3895 if (jj_scan_token(99)) return true;
3896 }
3897 if (jj_3R_153()) return true;
3898 return false;
3899 }
3900
3901 final private boolean jj_3R_87() {
3902 if (jj_3R_121()) return true;
3903 return false;
3904 }
3905
3906 final private boolean jj_3R_148() {
3907 if (jj_3R_153()) return true;
3908 Token xsp;
3909 while (true) {
3910 xsp = jj_scanpos;
3911 if (jj_3R_162()) { jj_scanpos = xsp; break; }
3912 }
3913 return false;
3914 }
3915
3916 final private boolean jj_3R_86() {
3917 if (jj_3R_120()) return true;
3918 return false;
3919 }
3920
3921 final private boolean jj_3R_85() {
3922 if (jj_3R_119()) return true;
3923 return false;
3924 }
3925
3926 final private boolean jj_3R_84() {
3927 if (jj_3R_118()) return true;
3928 return false;
3929 }
3930
3931 final private boolean jj_3R_159() {
3932 Token xsp;
3933 xsp = jj_scanpos;
3934 if (jj_scan_token(96)) {
3935 jj_scanpos = xsp;
3936 if (jj_scan_token(97)) return true;
3937 }
3938 if (jj_3R_148()) return true;
3939 return false;
3940 }
3941
3942 final private boolean jj_3R_83() {
3943 if (jj_3R_117()) return true;
3944 return false;
3945 }
3946
3947 final private boolean jj_3R_135() {
3948 if (jj_3R_148()) return true;
3949 Token xsp;
3950 while (true) {
3951 xsp = jj_scanpos;
3952 if (jj_3R_159()) { jj_scanpos = xsp; break; }
3953 }
3954 return false;
3955 }
3956
3957 final private boolean jj_3R_82() {
3958 if (jj_3R_116()) return true;
3959 return false;
3960 }
3961
3962 final private boolean jj_3R_81() {
3963 if (jj_3R_115()) return true;
3964 return false;
3965 }
3966
3967 final private boolean jj_3R_80() {
3968 if (jj_3R_114()) return true;
3969 return false;
3970 }
3971
3972 final private boolean jj_3R_108() {
3973 if (jj_3R_135()) return true;
3974 Token xsp;
3975 xsp = jj_scanpos;
3976 if (jj_3R_156()) jj_scanpos = xsp;
3977 return false;
3978 }
3979
3980 final private boolean jj_3R_79() {
3981 if (jj_3R_113()) return true;
3982 return false;
3983 }
3984
3985 final private boolean jj_3R_78() {
3986 if (jj_3R_112()) return true;
3987 if (jj_scan_token(SEMICOLON)) return true;
3988 return false;
3989 }
3990
3991 final private boolean jj_3_17() {
3992 if (jj_3R_38()) return true;
3993 return false;
3994 }
3995
3996 final private boolean jj_3R_77() {
3997 if (jj_3R_38()) return true;
3998 return false;
3999 }
4000
4001 final private boolean jj_3R_45() {
4002 Token xsp;
4003 xsp = jj_scanpos;
4004 if (jj_3_22()) {
4005 jj_scanpos = xsp;
4006 if (jj_3R_77()) {
4007 jj_scanpos = xsp;
4008 if (jj_scan_token(78)) {
4009 jj_scanpos = xsp;
4010 if (jj_3R_78()) {
4011 jj_scanpos = xsp;
4012 if (jj_3R_79()) {
4013 jj_scanpos = xsp;
4014 if (jj_3R_80()) {
4015 jj_scanpos = xsp;
4016 if (jj_3R_81()) {
4017 jj_scanpos = xsp;
4018 if (jj_3R_82()) {
4019 jj_scanpos = xsp;
4020 lookingAhead = true;
4021 jj_semLA = isRegularForStatement();
4022 lookingAhead = false;
4023 if (!jj_semLA || jj_3R_83()) {
4024 jj_scanpos = xsp;
4025 if (jj_3R_84()) {
4026 jj_scanpos = xsp;
4027 if (jj_3R_85()) {
4028 jj_scanpos = xsp;
4029 if (jj_3R_86()) {
4030 jj_scanpos = xsp;
4031 if (jj_3R_87()) {
4032 jj_scanpos = xsp;
4033 if (jj_3R_88()) {
4034 jj_scanpos = xsp;
4035 if (jj_3R_89()) {
4036 jj_scanpos = xsp;
4037 if (jj_3R_90()) return true;
4038 }
4039 }
4040 }
4041 }
4042 }
4043 }
4044 }
4045 }
4046 }
4047 }
4048 }
4049 }
4050 }
4051 }
4052 }
4053 return false;
4054 }
4055
4056 final private boolean jj_3_22() {
4057 if (jj_3R_40()) return true;
4058 return false;
4059 }
4060
4061 final private boolean jj_3R_34() {
4062 Token xsp;
4063 xsp = jj_scanpos;
4064 if (jj_scan_token(81)) {
4065 jj_scanpos = xsp;
4066 if (jj_scan_token(120)) {
4067 jj_scanpos = xsp;
4068 if (jj_scan_token(121)) {
4069 jj_scanpos = xsp;
4070 if (jj_scan_token(127)) {
4071 jj_scanpos = xsp;
4072 if (jj_scan_token(118)) {
4073 jj_scanpos = xsp;
4074 if (jj_scan_token(119)) {
4075 jj_scanpos = xsp;
4076 if (jj_scan_token(122)) {
4077 jj_scanpos = xsp;
4078 if (jj_scan_token(126)) {
4079 jj_scanpos = xsp;
4080 if (jj_scan_token(124)) {
4081 jj_scanpos = xsp;
4082 if (jj_scan_token(128)) {
4083 jj_scanpos = xsp;
4084 if (jj_scan_token(129)) {
4085 jj_scanpos = xsp;
4086 if (jj_scan_token(130)) {
4087 jj_scanpos = xsp;
4088 if (jj_scan_token(131)) {
4089 jj_scanpos = xsp;
4090 if (jj_scan_token(132)) {
4091 jj_scanpos = xsp;
4092 if (jj_scan_token(133)) return true;
4093 }
4094 }
4095 }
4096 }
4097 }
4098 }
4099 }
4100 }
4101 }
4102 }
4103 }
4104 }
4105 }
4106 }
4107 return false;
4108 }
4109
4110 final private boolean jj_3R_111() {
4111 if (jj_scan_token(COMMA)) return true;
4112 if (jj_3R_29()) return true;
4113 return false;
4114 }
4115
4116 final private boolean jj_3R_160() {
4117 if (jj_scan_token(LBRACKET)) return true;
4118 if (jj_scan_token(RBRACKET)) return true;
4119 return false;
4120 }
4121
4122 final private boolean jj_3R_152() {
4123 if (jj_3R_69()) return true;
4124 Token xsp;
4125 xsp = jj_scanpos;
4126 if (jj_3_17()) jj_scanpos = xsp;
4127 return false;
4128 }
4129
4130 final private boolean jj_3R_157() {
4131 Token xsp;
4132 if (jj_3R_160()) return true;
4133 while (true) {
4134 xsp = jj_scanpos;
4135 if (jj_3R_160()) { jj_scanpos = xsp; break; }
4136 }
4137 if (jj_3R_97()) return true;
4138 return false;
4139 }
4140
4141 final private boolean jj_3_8() {
4142 if (jj_3R_33()) return true;
4143 if (jj_3R_34()) return true;
4144 return false;
4145 }
4146
4147 final private boolean jj_3_20() {
4148 if (jj_scan_token(LBRACKET)) return true;
4149 if (jj_scan_token(RBRACKET)) return true;
4150 return false;
4151 }
4152
4153 final private boolean jj_3R_151() {
4154 if (jj_3R_150()) return true;
4155 return false;
4156 }
4157
4158 final private boolean jj_3_19() {
4159 if (jj_scan_token(LBRACKET)) return true;
4160 if (jj_3R_39()) return true;
4161 if (jj_scan_token(RBRACKET)) return true;
4162 return false;
4163 }
4164
4165 final private boolean jj_3R_107() {
4166 if (jj_3R_33()) return true;
4167 if (jj_3R_34()) return true;
4168 if (jj_3R_39()) return true;
4169 return false;
4170 }
4171
4172 final private boolean jj_3_21() {
4173 Token xsp;
4174 if (jj_3_19()) return true;
4175 while (true) {
4176 xsp = jj_scanpos;
4177 if (jj_3_19()) { jj_scanpos = xsp; break; }
4178 }
4179 while (true) {
4180 xsp = jj_scanpos;
4181 if (jj_3_20()) { jj_scanpos = xsp; break; }
4182 }
4183 return false;
4184 }
4185
4186 final private boolean jj_3R_150() {
4187 Token xsp;
4188 xsp = jj_scanpos;
4189 if (jj_3_21()) {
4190 jj_scanpos = xsp;
4191 if (jj_3R_157()) return true;
4192 }
4193 return false;
4194 }
4195
4196 final private boolean jj_3R_71() {
4197 if (jj_3R_108()) return true;
4198 return false;
4199 }
4200
4201 final private boolean jj_3R_39() {
4202 Token xsp;
4203 xsp = jj_scanpos;
4204 if (jj_3R_70()) {
4205 jj_scanpos = xsp;
4206 if (jj_3R_71()) return true;
4207 }
4208 return false;
4209 }
4210
4211 final private boolean jj_3R_70() {
4212 if (jj_3R_107()) return true;
4213 return false;
4214 }
4215
4216 final private boolean jj_3R_145() {
4217 if (jj_scan_token(NEW)) return true;
4218 if (jj_3R_29()) return true;
4219 Token xsp;
4220 xsp = jj_scanpos;
4221 if (jj_3R_151()) {
4222 jj_scanpos = xsp;
4223 if (jj_3R_152()) return true;
4224 }
4225 return false;
4226 }
4227
4228 final private boolean jj_3_18() {
4229 if (jj_scan_token(NEW)) return true;
4230 if (jj_3R_36()) return true;
4231 if (jj_3R_150()) return true;
4232 return false;
4233 }
4234
4235 final private boolean jj_3R_130() {
4236 Token xsp;
4237 xsp = jj_scanpos;
4238 if (jj_3_18()) {
4239 jj_scanpos = xsp;
4240 if (jj_3R_145()) return true;
4241 }
4242 return false;
4243 }
4244
4245 final private boolean jj_3R_147() {
4246 if (jj_scan_token(COMMA)) return true;
4247 if (jj_3R_39()) return true;
4248 return false;
4249 }
4250
4251 final private boolean jj_3R_76() {
4252 if (jj_3R_29()) return true;
4253 Token xsp;
4254 while (true) {
4255 xsp = jj_scanpos;
4256 if (jj_3R_111()) { jj_scanpos = xsp; break; }
4257 }
4258 return false;
4259 }
4260
4261 final private boolean jj_3R_134() {
4262 if (jj_3R_39()) return true;
4263 Token xsp;
4264 while (true) {
4265 xsp = jj_scanpos;
4266 if (jj_3R_147()) { jj_scanpos = xsp; break; }
4267 }
4268 return false;
4269 }
4270
4271 final private boolean jj_3R_106() {
4272 if (jj_3R_134()) return true;
4273 return false;
4274 }
4275
4276 final private boolean jj_3_7() {
4277 if (jj_scan_token(DOT)) return true;
4278 if (jj_scan_token(IDENTIFIER)) return true;
4279 return false;
4280 }
4281
4282 final private boolean jj_3R_69() {
4283 if (jj_scan_token(LPAREN)) return true;
4284 Token xsp;
4285 xsp = jj_scanpos;
4286 if (jj_3R_106()) jj_scanpos = xsp;
4287 if (jj_scan_token(RPAREN)) return true;
4288 return false;
4289 }
4290
4291 final private boolean jj_3R_29() {
4292 if (jj_scan_token(IDENTIFIER)) return true;
4293 Token xsp;
4294 while (true) {
4295 xsp = jj_scanpos;
4296 if (jj_3_7()) { jj_scanpos = xsp; break; }
4297 }
4298 return false;
4299 }
4300
4301 final private boolean jj_3R_68() {
4302 if (jj_scan_token(DOUBLE)) return true;
4303 return false;
4304 }
4305
4306 final private boolean jj_3R_67() {
4307 if (jj_scan_token(FLOAT)) return true;
4308 return false;
4309 }
4310
4311 final private boolean jj_3R_155() {
4312 if (jj_scan_token(FALSE)) return true;
4313 return false;
4314 }
4315
4316 final private boolean jj_3R_66() {
4317 if (jj_scan_token(LONG)) return true;
4318 return false;
4319 }
4320
4321 final private boolean jj_3R_65() {
4322 if (jj_scan_token(INT)) return true;
4323 return false;
4324 }
4325
4326 final private boolean jj_3R_154() {
4327 if (jj_scan_token(TRUE)) return true;
4328 return false;
4329 }
4330
4331 final private boolean jj_3R_149() {
4332 Token xsp;
4333 xsp = jj_scanpos;
4334 if (jj_3R_154()) {
4335 jj_scanpos = xsp;
4336 if (jj_3R_155()) return true;
4337 }
4338 return false;
4339 }
4340
4341 final private boolean jj_3R_64() {
4342 if (jj_scan_token(SHORT)) return true;
4343 return false;
4344 }
4345
4346 final private boolean jj_3R_56() {
4347 if (jj_3R_29()) return true;
4348 return false;
4349 }
4350
4351 final private boolean jj_3R_63() {
4352 if (jj_scan_token(BYTE)) return true;
4353 return false;
4354 }
4355
4356 final private boolean jj_3R_62() {
4357 if (jj_scan_token(CHAR)) return true;
4358 return false;
4359 }
4360
4361 final private boolean jj_3R_61() {
4362 if (jj_scan_token(BOOLEAN)) return true;
4363 return false;
4364 }
4365
4366 final private boolean jj_3R_36() {
4367 Token xsp;
4368 xsp = jj_scanpos;
4369 if (jj_3R_61()) {
4370 jj_scanpos = xsp;
4371 if (jj_3R_62()) {
4372 jj_scanpos = xsp;
4373 if (jj_3R_63()) {
4374 jj_scanpos = xsp;
4375 if (jj_3R_64()) {
4376 jj_scanpos = xsp;
4377 if (jj_3R_65()) {
4378 jj_scanpos = xsp;
4379 if (jj_3R_66()) {
4380 jj_scanpos = xsp;
4381 if (jj_3R_67()) {
4382 jj_scanpos = xsp;
4383 if (jj_3R_68()) return true;
4384 }
4385 }
4386 }
4387 }
4388 }
4389 }
4390 }
4391 return false;
4392 }
4393
4394 final private boolean jj_3R_144() {
4395 if (jj_scan_token(57)) return true;
4396 return false;
4397 }
4398
4399 final private boolean jj_3R_74() {
4400 if (jj_3R_32()) return true;
4401 return false;
4402 }
4403
4404 final private boolean jj_3R_42() {
4405 Token xsp;
4406 xsp = jj_scanpos;
4407 if (jj_3R_73()) {
4408 jj_scanpos = xsp;
4409 if (jj_3R_74()) return true;
4410 }
4411 return false;
4412 }
4413
4414 final private boolean jj_3R_73() {
4415 if (jj_scan_token(VOID)) return true;
4416 return false;
4417 }
4418
4419 final private boolean jj_3R_143() {
4420 if (jj_scan_token(41)) return true;
4421 return false;
4422 }
4423
4424 final private boolean jj_3_6() {
4425 if (jj_scan_token(LBRACKET)) return true;
4426 if (jj_scan_token(RBRACKET)) return true;
4427 return false;
4428 }
4429
4430 final private boolean jj_3R_142() {
4431 if (jj_3R_149()) return true;
4432 return false;
4433 }
4434
4435 final private boolean jj_3R_55() {
4436 if (jj_3R_36()) return true;
4437 return false;
4438 }
4439
4440 final private boolean jj_3R_110() {
4441 if (jj_scan_token(COMMA)) return true;
4442 if (jj_3R_109()) return true;
4443 return false;
4444 }
4445
4446 final private boolean jj_3R_141() {
4447 if (jj_scan_token(STRING_LITERAL)) return true;
4448 return false;
4449 }
4450
4451 final private boolean jj_3R_32() {
4452 Token xsp;
4453 xsp = jj_scanpos;
4454 if (jj_3R_55()) {
4455 jj_scanpos = xsp;
4456 if (jj_3R_56()) return true;
4457 }
4458 while (true) {
4459 xsp = jj_scanpos;
4460 if (jj_3_6()) { jj_scanpos = xsp; break; }
4461 }
4462 return false;
4463 }
4464
4465 final private boolean jj_3R_140() {
4466 if (jj_scan_token(CHARACTER_LITERAL)) return true;
4467 return false;
4468 }
4469
4470 final private boolean jj_3R_190() {
4471 if (jj_scan_token(FINALLY)) return true;
4472 if (jj_3R_38()) return true;
4473 return false;
4474 }
4475
4476 final private boolean jj_3_4() {
4477 if (jj_scan_token(COMMA)) return true;
4478 if (jj_3R_31()) return true;
4479 return false;
4480 }
4481
4482 final private boolean jj_3R_189() {
4483 if (jj_scan_token(CATCH)) return true;
4484 if (jj_scan_token(LPAREN)) return true;
4485 if (jj_3R_109()) return true;
4486 if (jj_scan_token(RPAREN)) return true;
4487 if (jj_3R_38()) return true;
4488 return false;
4489 }
4490
4491 final private boolean jj_3R_136() {
4492 if (jj_scan_token(IDENTIFIER)) return true;
4493 return false;
4494 }
4495
4496 final private boolean jj_3_5() {
4497 if (jj_3R_32()) return true;
4498 if (jj_scan_token(IDENTIFIER)) return true;
4499 return false;
4500 }
4501
4502 final private boolean jj_3R_75() {
4503 if (jj_3R_109()) return true;
4504 Token xsp;
4505 while (true) {
4506 xsp = jj_scanpos;
4507 if (jj_3R_110()) { jj_scanpos = xsp; break; }
4508 }
4509 return false;
4510 }
4511
4512 final private boolean jj_3R_109() {
4513 Token xsp;
4514 xsp = jj_scanpos;
4515 if (jj_3_5()) {
4516 jj_scanpos = xsp;
4517 if (jj_3R_136()) return true;
4518 }
4519 return false;
4520 }
4521
4522 final private boolean jj_3R_124() {
4523 if (jj_scan_token(TRY)) return true;
4524 if (jj_3R_38()) return true;
4525 Token xsp;
4526 while (true) {
4527 xsp = jj_scanpos;
4528 if (jj_3R_189()) { jj_scanpos = xsp; break; }
4529 }
4530 xsp = jj_scanpos;
4531 if (jj_3R_190()) jj_scanpos = xsp;
4532 return false;
4533 }
4534
4535 final private boolean jj_3R_43() {
4536 if (jj_scan_token(LPAREN)) return true;
4537 Token xsp;
4538 xsp = jj_scanpos;
4539 if (jj_3R_75()) jj_scanpos = xsp;
4540 if (jj_scan_token(RPAREN)) return true;
4541 return false;
4542 }
4543
4544 final private boolean jj_3R_163() {
4545 if (jj_3R_31()) return true;
4546 Token xsp;
4547 while (true) {
4548 xsp = jj_scanpos;
4549 if (jj_3_4()) { jj_scanpos = xsp; break; }
4550 }
4551 return false;
4552 }
4553
4554 final private boolean jj_3R_139() {
4555 if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
4556 return false;
4557 }
4558
4559 final private boolean jj_3R_97() {
4560 if (jj_scan_token(LBRACE)) return true;
4561 Token xsp;
4562 xsp = jj_scanpos;
4563 if (jj_3R_163()) jj_scanpos = xsp;
4564 xsp = jj_scanpos;
4565 if (jj_scan_token(79)) jj_scanpos = xsp;
4566 if (jj_scan_token(RBRACE)) return true;
4567 return false;
4568 }
4569
4570 final private boolean jj_3R_30() {
4571 if (jj_scan_token(DOT)) return true;
4572 if (jj_scan_token(STAR)) return true;
4573 return false;
4574 }
4575
4576 final private boolean jj_3R_123() {
4577 if (jj_scan_token(THROW)) return true;
4578 if (jj_3R_39()) return true;
4579 if (jj_scan_token(SEMICOLON)) return true;
4580 return false;
4581 }
4582
4583 final private boolean jj_3R_180() {
4584 if (jj_scan_token(ASSIGN)) return true;
4585 if (jj_3R_31()) return true;
4586 return false;
4587 }
4588
4589 final private boolean jj_3R_54() {
4590 if (jj_3R_39()) return true;
4591 return false;
4592 }
4593
4594 final private boolean jj_3R_188() {
4595 if (jj_3R_39()) return true;
4596 return false;
4597 }
4598
4599 final private boolean jj_3R_53() {
4600 if (jj_3R_97()) return true;
4601 return false;
4602 }
4603
4604 final private boolean jj_3R_31() {
4605 Token xsp;
4606 xsp = jj_scanpos;
4607 if (jj_3R_53()) {
4608 jj_scanpos = xsp;
4609 if (jj_3R_54()) return true;
4610 }
4611 return false;
4612 }
4613
4614 final private boolean jj_3R_122() {
4615 if (jj_scan_token(SYNCHRONIZED)) return true;
4616 if (jj_scan_token(LPAREN)) return true;
4617 if (jj_3R_39()) return true;
4618 if (jj_scan_token(RPAREN)) return true;
4619 if (jj_3R_38()) return true;
4620 return false;
4621 }
4622
4623 final private boolean jj_3R_177() {
4624 if (jj_scan_token(COMMA)) return true;
4625 if (jj_3R_176()) return true;
4626 return false;
4627 }
4628
4629 final private boolean jj_3R_210() {
4630 if (jj_scan_token(COMMA)) return true;
4631 if (jj_3R_112()) return true;
4632 return false;
4633 }
4634
4635 final private boolean jj_3R_121() {
4636 if (jj_scan_token(RETURN)) return true;
4637 Token xsp;
4638 xsp = jj_scanpos;
4639 if (jj_3R_188()) jj_scanpos = xsp;
4640 if (jj_scan_token(SEMICOLON)) return true;
4641 return false;
4642 }
4643
4644 final private boolean jj_3R_129() {
4645 Token xsp;
4646 xsp = jj_scanpos;
4647 if (jj_3R_138()) {
4648 jj_scanpos = xsp;
4649 if (jj_3R_139()) {
4650 jj_scanpos = xsp;
4651 if (jj_3R_140()) {
4652 jj_scanpos = xsp;
4653 if (jj_3R_141()) {
4654 jj_scanpos = xsp;
4655 if (jj_3R_142()) {
4656 jj_scanpos = xsp;
4657 if (jj_3R_143()) {
4658 jj_scanpos = xsp;
4659 if (jj_3R_144()) return true;
4660 }
4661 }
4662 }
4663 }
4664 }
4665 }
4666 return false;
4667 }
4668
4669 final private boolean jj_3R_138() {
4670 if (jj_scan_token(INTEGER_LITERAL)) return true;
4671 return false;
4672 }
4673
4674 final private boolean jj_3R_146() {
4675 if (jj_3R_69()) return true;
4676 return false;
4677 }
4678
4679 final private boolean jj_3R_176() {
4680 if (jj_scan_token(IDENTIFIER)) return true;
4681 Token xsp;
4682 xsp = jj_scanpos;
4683 if (jj_3R_180()) jj_scanpos = xsp;
4684 return false;
4685 }
4686
4687 final private boolean jj_3R_105() {
4688 if (jj_3R_129()) return true;
4689 return false;
4690 }
4691
4692 final private boolean jj_3R_120() {
4693 if (jj_scan_token(CONTINUE)) return true;
4694 Token xsp;
4695 xsp = jj_scanpos;
4696 if (jj_scan_token(69)) jj_scanpos = xsp;
4697 if (jj_scan_token(SEMICOLON)) return true;
4698 return false;
4699 }
4700
4701 final private boolean jj_3R_119() {
4702 if (jj_scan_token(BREAK)) return true;
4703 Token xsp;
4704 xsp = jj_scanpos;
4705 if (jj_scan_token(69)) jj_scanpos = xsp;
4706 if (jj_scan_token(SEMICOLON)) return true;
4707 return false;
4708 }
4709
4710 final private boolean jj_3R_195() {
4711 if (jj_3R_205()) return true;
4712 return false;
4713 }
4714
4715 final private boolean jj_3R_128() {
4716 if (jj_scan_token(IMPORT)) return true;
4717 if (jj_scan_token(STAR)) return true;
4718 if (jj_scan_token(SEMICOLON)) return true;
4719 return false;
4720 }
4721
4722 final private boolean jj_3R_133() {
4723 if (jj_scan_token(LBRACE)) return true;
4724 if (jj_3R_39()) return true;
4725 if (jj_scan_token(RBRACE)) return true;
4726 return false;
4727 }
4728
4729 final private boolean jj_3R_205() {
4730 if (jj_3R_112()) return true;
4731 Token xsp;
4732 while (true) {
4733 xsp = jj_scanpos;
4734 if (jj_3R_210()) { jj_scanpos = xsp; break; }
4735 }
4736 return false;
4737 }
4738
4739 final private boolean jj_3R_132() {
4740 if (jj_scan_token(DOT)) return true;
4741 if (jj_scan_token(IDENTIFIER)) return true;
4742 Token xsp;
4743 xsp = jj_scanpos;
4744 if (jj_3R_146()) jj_scanpos = xsp;
4745 return false;
4746 }
4747
4748 final private boolean jj_3_3() {
4749 Token xsp;
4750 xsp = jj_scanpos;
4751 if (jj_scan_token(48)) jj_scanpos = xsp;
4752 if (jj_scan_token(IMPORT)) return true;
4753 if (jj_3R_29()) return true;
4754 xsp = jj_scanpos;
4755 if (jj_3R_30()) jj_scanpos = xsp;
4756 if (jj_scan_token(SEMICOLON)) return true;
4757 return false;
4758 }
4759
4760 final private boolean jj_3R_94() {
4761 Token xsp;
4762 xsp = jj_scanpos;
4763 if (jj_3_3()) {
4764 jj_scanpos = xsp;
4765 if (jj_3R_128()) return true;
4766 }
4767 return false;
4768 }
4769
4770 final private boolean jj_3R_93() {
4771 if (jj_3R_41()) return true;
4772 if (jj_3R_32()) return true;
4773 if (jj_3R_176()) return true;
4774 Token xsp;
4775 while (true) {
4776 xsp = jj_scanpos;
4777 if (jj_3R_177()) { jj_scanpos = xsp; break; }
4778 }
4779 return false;
4780 }
4781
4782 final private boolean jj_3R_131() {
4783 if (jj_scan_token(LBRACKET)) return true;
4784 if (jj_3R_39()) return true;
4785 if (jj_scan_token(RBRACKET)) return true;
4786 return false;
4787 }
4788
4789 final private boolean jj_3R_95() {
4790 if (jj_scan_token(PACKAGE)) return true;
4791 if (jj_3R_29()) return true;
4792 return false;
4793 }
4794
4795 final private boolean jj_3_2() {
4796 if (jj_scan_token(IDENTIFIER)) return true;
4797 if (jj_scan_token(LPAREN)) return true;
4798 return false;
4799 }
4800
4801 final private boolean jj_3R_175() {
4802 if (jj_3R_38()) return true;
4803 return false;
4804 }
4805
4806 final private boolean jj_3_16() {
4807 if (jj_scan_token(DOT)) return true;
4808 if (jj_scan_token(CLASS)) return true;
4809 return false;
4810 }
4811
4812 final private boolean jj_3R_104() {
4813 Token xsp;
4814 xsp = jj_scanpos;
4815 if (jj_3_16()) {
4816 jj_scanpos = xsp;
4817 if (jj_3R_131()) {
4818 jj_scanpos = xsp;
4819 if (jj_3R_132()) {
4820 jj_scanpos = xsp;
4821 if (jj_3R_133()) return true;
4822 }
4823 }
4824 }
4825 return false;
4826 }
4827
4828 final private boolean jj_3R_174() {
4829 if (jj_scan_token(THROWS)) return true;
4830 if (jj_3R_76()) return true;
4831 return false;
4832 }
4833
4834 final private boolean jj_3_15() {
4835 if (jj_3R_32()) return true;
4836 if (jj_scan_token(DOT)) return true;
4837 if (jj_scan_token(CLASS)) return true;
4838 return false;
4839 }
4840
4841 final private boolean jj_3_31() {
4842 if (jj_3R_41()) return true;
4843 if (jj_3R_32()) return true;
4844 if (jj_scan_token(IDENTIFIER)) return true;
4845 return false;
4846 }
4847
4848 final private boolean jj_3_14() {
4849 if (jj_3R_37()) return true;
4850 return false;
4851 }
4852
4853 final private boolean jj_3R_126() {
4854 if (jj_scan_token(IDENTIFIER)) return true;
4855 return false;
4856 }
4857
4858 final private boolean jj_3R_127() {
4859 if (jj_3R_42()) return true;
4860 if (jj_scan_token(IDENTIFIER)) return true;
4861 return false;
4862 }
4863
4864 final private boolean jj_3R_92() {
4865 if (jj_3R_41()) return true;
4866 Token xsp;
4867 xsp = jj_scanpos;
4868 if (jj_3R_126()) {
4869 jj_scanpos = xsp;
4870 if (jj_3R_127()) return true;
4871 }
4872 if (jj_3R_43()) return true;
4873 xsp = jj_scanpos;
4874 if (jj_3R_174()) jj_scanpos = xsp;
4875 xsp = jj_scanpos;
4876 if (jj_3R_175()) {
4877 jj_scanpos = xsp;
4878 if (jj_scan_token(78)) return true;
4879 }
4880 return false;
4881 }
4882
4883 final private boolean jj_3R_204() {
4884 if (jj_3R_205()) return true;
4885 return false;
4886 }
4887
4888 final private boolean jj_3R_103() {
4889 if (jj_3R_29()) return true;
4890 return false;
4891 }
4892
4893 final private boolean jj_3R_203() {
4894 if (jj_3R_93()) return true;
4895 return false;
4896 }
4897
4898 final private boolean jj_3R_194() {
4899 Token xsp;
4900 xsp = jj_scanpos;
4901 if (jj_3R_203()) {
4902 jj_scanpos = xsp;
4903 if (jj_3R_204()) return true;
4904 }
4905 return false;
4906 }
4907
4908 final private boolean jj_3R_102() {
4909 if (jj_3R_32()) return true;
4910 return false;
4911 }
4912
4913 final private boolean jj_3R_58() {
4914 if (jj_3R_104()) return true;
4915 return false;
4916 }
4917
4918 final private boolean jj_3R_125() {
4919 if (jj_scan_token(INTERFACE)) return true;
4920 return false;
4921 }
4922
4923 final private boolean jj_3R_101() {
4924 if (jj_3R_37()) return true;
4925 return false;
4926 }
4927
4928 final private boolean jj_3R_100() {
4929 if (jj_3R_130()) return true;
4930 return false;
4931 }
4932
4933 final private boolean jj_3R_99() {
4934 if (jj_scan_token(LPAREN)) return true;
4935 if (jj_3R_39()) return true;
4936 if (jj_scan_token(RPAREN)) return true;
4937 return false;
4938 }
4939
4940 final private boolean jj_3R_137() {
4941 if (jj_scan_token(FOR)) return true;
4942 if (jj_scan_token(LPAREN)) return true;
4943 if (jj_3R_32()) return true;
4944 if (jj_scan_token(IDENTIFIER)) return true;
4945 if (jj_scan_token(COLON)) return true;
4946 if (jj_3R_39()) return true;
4947 if (jj_scan_token(RPAREN)) return true;
4948 if (jj_3R_45()) return true;
4949 return false;
4950 }
4951
4952 final private boolean jj_3R_184() {
4953 if (jj_scan_token(ELSE)) return true;
4954 if (jj_3R_45()) return true;
4955 return false;
4956 }
4957
4958 final private boolean jj_3R_173() {
4959 if (jj_scan_token(IMPLEMENTS)) return true;
4960 if (jj_3R_76()) return true;
4961 return false;
4962 }
4963
4964 final private boolean jj_3R_57() {
4965 Token xsp;
4966 xsp = jj_scanpos;
4967 if (jj_3R_98()) {
4968 jj_scanpos = xsp;
4969 if (jj_3R_99()) {
4970 jj_scanpos = xsp;
4971 if (jj_3R_100()) {
4972 jj_scanpos = xsp;
4973 if (jj_3R_101()) {
4974 jj_scanpos = xsp;
4975 if (jj_3R_102()) {
4976 jj_scanpos = xsp;
4977 if (jj_3R_103()) return true;
4978 }
4979 }
4980 }
4981 }
4982 }
4983 return false;
4984 }
4985
4986 final private boolean jj_3R_98() {
4987 if (jj_3R_129()) return true;
4988 return false;
4989 }
4990
4991 final private boolean jj_3R_172() {
4992 if (jj_scan_token(EXTENDS)) return true;
4993 if (jj_3R_29()) return true;
4994 return false;
4995 }
4996
4997 final private boolean jj_3_30() {
4998 if (jj_scan_token(FOR)) return true;
4999 if (jj_scan_token(LPAREN)) return true;
5000 if (jj_scan_token(IDENTIFIER)) return true;
5001 if (jj_scan_token(COLON)) return true;
5002 if (jj_3R_39()) return true;
5003 if (jj_scan_token(RPAREN)) return true;
5004 if (jj_3R_45()) return true;
5005 return false;
5006 }
5007
5008 final private boolean jj_3R_118() {
5009 Token xsp;
5010 xsp = jj_scanpos;
5011 if (jj_3_30()) {
5012 jj_scanpos = xsp;
5013 if (jj_3R_137()) return true;
5014 }
5015 return false;
5016 }
5017
5018 final private boolean jj_3R_37() {
5019 if (jj_3R_29()) return true;
5020 if (jj_3R_69()) return true;
5021 return false;
5022 }
5023
5024 final private boolean jj_3R_185() {
5025 if (jj_3R_194()) return true;
5026 return false;
5027 }
5028
5029 final private boolean jj_3R_91() {
5030 if (jj_3R_41()) return true;
5031 Token xsp;
5032 xsp = jj_scanpos;
5033 if (jj_scan_token(13)) {
5034 jj_scanpos = xsp;
5035 if (jj_3R_125()) return true;
5036 }
5037 if (jj_scan_token(IDENTIFIER)) return true;
5038 xsp = jj_scanpos;
5039 if (jj_3R_172()) jj_scanpos = xsp;
5040 xsp = jj_scanpos;
5041 if (jj_3R_173()) jj_scanpos = xsp;
5042 if (jj_3R_38()) return true;
5043 return false;
5044 }
5045
5046 final private boolean jj_3_13() {
5047 if (jj_scan_token(LPAREN)) return true;
5048 if (jj_3R_36()) return true;
5049 return false;
5050 }
5051
5052 final private boolean jj_3R_187() {
5053 if (jj_3R_195()) return true;
5054 return false;
5055 }
5056
5057 final private boolean jj_3R_186() {
5058 if (jj_3R_39()) return true;
5059 return false;
5060 }
5061
5062 final private boolean jj_3R_33() {
5063 if (jj_3R_57()) return true;
5064 Token xsp;
5065 while (true) {
5066 xsp = jj_scanpos;
5067 if (jj_3R_58()) { jj_scanpos = xsp; break; }
5068 }
5069 return false;
5070 }
5071
5072 final private boolean jj_3R_217() {
5073 if (jj_scan_token(LPAREN)) return true;
5074 if (jj_3R_32()) return true;
5075 if (jj_scan_token(RPAREN)) return true;
5076 if (jj_3R_208()) return true;
5077 return false;
5078 }
5079
5080 final private boolean jj_3R_216() {
5081 if (jj_scan_token(LPAREN)) return true;
5082 if (jj_3R_32()) return true;
5083 if (jj_scan_token(RPAREN)) return true;
5084 if (jj_3R_191()) return true;
5085 return false;
5086 }
5087
5088 final private boolean jj_3R_117() {
5089 if (jj_scan_token(FOR)) return true;
5090 if (jj_scan_token(LPAREN)) return true;
5091 Token xsp;
5092 xsp = jj_scanpos;
5093 if (jj_3R_185()) jj_scanpos = xsp;
5094 if (jj_scan_token(SEMICOLON)) return true;
5095 xsp = jj_scanpos;
5096 if (jj_3R_186()) jj_scanpos = xsp;
5097 if (jj_scan_token(SEMICOLON)) return true;
5098 xsp = jj_scanpos;
5099 if (jj_3R_187()) jj_scanpos = xsp;
5100 if (jj_scan_token(RPAREN)) return true;
5101 if (jj_3R_45()) return true;
5102 return false;
5103 }
5104
5105 final private boolean jj_3R_214() {
5106 Token xsp;
5107 xsp = jj_scanpos;
5108 if (jj_3R_216()) {
5109 jj_scanpos = xsp;
5110 if (jj_3R_217()) return true;
5111 }
5112 return false;
5113 }
5114
5115 final private boolean jj_3_12() {
5116 if (jj_3R_33()) return true;
5117 Token xsp;
5118 xsp = jj_scanpos;
5119 if (jj_scan_token(100)) {
5120 jj_scanpos = xsp;
5121 if (jj_scan_token(101)) return true;
5122 }
5123 return false;
5124 }
5125
5126 final private boolean jj_3R_219() {
5127 if (jj_3R_33()) return true;
5128 return false;
5129 }
5130
5131 final private boolean jj_3R_116() {
5132 if (jj_scan_token(DO)) return true;
5133 if (jj_3R_45()) return true;
5134 if (jj_scan_token(WHILE)) return true;
5135 if (jj_scan_token(LPAREN)) return true;
5136 if (jj_3R_39()) return true;
5137 if (jj_scan_token(RPAREN)) return true;
5138 if (jj_scan_token(SEMICOLON)) return true;
5139 return false;
5140 }
5141
5142 final private boolean jj_3_11() {
5143 if (jj_scan_token(LPAREN)) return true;
5144 if (jj_3R_29()) return true;
5145 if (jj_scan_token(LBRACKET)) return true;
5146 return false;
5147 }
5148
5149 final private boolean jj_3R_218() {
5150 if (jj_3R_33()) return true;
5151 Token xsp;
5152 xsp = jj_scanpos;
5153 if (jj_scan_token(100)) {
5154 jj_scanpos = xsp;
5155 if (jj_scan_token(101)) return true;
5156 }
5157 return false;
5158 }
5159
5160 final private boolean jj_3R_215() {
5161 Token xsp;
5162 xsp = jj_scanpos;
5163 if (jj_3R_218()) {
5164 jj_scanpos = xsp;
5165 if (jj_3R_219()) return true;
5166 }
5167 return false;
5168 }
5169
5170 final private boolean jj_3R_72() {
5171 Token xsp;
5172 xsp = jj_scanpos;
5173 if (jj_scan_token(43)) {
5174 jj_scanpos = xsp;
5175 if (jj_scan_token(44)) {
5176 jj_scanpos = xsp;
5177 if (jj_scan_token(45)) {
5178 jj_scanpos = xsp;
5179 if (jj_scan_token(51)) {
5180 jj_scanpos = xsp;
5181 if (jj_scan_token(27)) {
5182 jj_scanpos = xsp;
5183 if (jj_scan_token(39)) {
5184 jj_scanpos = xsp;
5185 if (jj_scan_token(52)) {
5186 jj_scanpos = xsp;
5187 if (jj_scan_token(58)) {
5188 jj_scanpos = xsp;
5189 if (jj_scan_token(10)) {
5190 jj_scanpos = xsp;
5191 if (jj_scan_token(48)) {
5192 jj_scanpos = xsp;
5193 if (jj_scan_token(49)) return true;
5194 }
5195 }
5196 }
5197 }
5198 }
5199 }
5200 }
5201 }
5202 }
5203 }
5204 return false;
5205 }
5206
5207 final private boolean jj_3R_115() {
5208 if (jj_scan_token(WHILE)) return true;
5209 if (jj_scan_token(LPAREN)) return true;
5210 if (jj_3R_39()) return true;
5211 if (jj_scan_token(RPAREN)) return true;
5212 if (jj_3R_45()) return true;
5213 return false;
5214 }
5215
5216 final private boolean jj_3R_60() {
5217 if (jj_scan_token(LPAREN)) return true;
5218 if (jj_3R_29()) return true;
5219 if (jj_scan_token(RPAREN)) return true;
5220 Token xsp;
5221 xsp = jj_scanpos;
5222 if (jj_scan_token(87)) {
5223 jj_scanpos = xsp;
5224 if (jj_scan_token(86)) {
5225 jj_scanpos = xsp;
5226 if (jj_scan_token(72)) {
5227 jj_scanpos = xsp;
5228 if (jj_scan_token(69)) {
5229 jj_scanpos = xsp;
5230 if (jj_scan_token(40)) {
5231 jj_scanpos = xsp;
5232 if (jj_3R_105()) return true;
5233 }
5234 }
5235 }
5236 }
5237 }
5238 return false;
5239 }
5240
5241 final private boolean jj_3R_59() {
5242 if (jj_scan_token(LPAREN)) return true;
5243 if (jj_3R_29()) return true;
5244 if (jj_scan_token(LBRACKET)) return true;
5245 if (jj_scan_token(RBRACKET)) return true;
5246 return false;
5247 }
5248
5249 final private boolean jj_3_9() {
5250 if (jj_3R_35()) return true;
5251 return false;
5252 }
5253
5254 final private boolean jj_3_29() {
5255 if (jj_3R_28()) return true;
5256 return false;
5257 }
5258
5259 final private boolean jj_3R_114() {
5260 if (jj_scan_token(IF)) return true;
5261 if (jj_scan_token(LPAREN)) return true;
5262 if (jj_3R_39()) return true;
5263 if (jj_scan_token(RPAREN)) return true;
5264 if (jj_3R_45()) return true;
5265 Token xsp;
5266 xsp = jj_scanpos;
5267 if (jj_3R_184()) jj_scanpos = xsp;
5268 return false;
5269 }
5270
5271 final private boolean jj_3R_41() {
5272 Token xsp;
5273 while (true) {
5274 xsp = jj_scanpos;
5275 if (jj_3R_72()) { jj_scanpos = xsp; break; }
5276 }
5277 return false;
5278 }
5279
5280 final private boolean jj_3R_35() {
5281 Token xsp;
5282 xsp = jj_scanpos;
5283 if (jj_3_10()) {
5284 jj_scanpos = xsp;
5285 if (jj_3R_59()) {
5286 jj_scanpos = xsp;
5287 if (jj_3R_60()) return true;
5288 }
5289 }
5290 return false;
5291 }
5292
5293 final private boolean jj_3_10() {
5294 if (jj_scan_token(LPAREN)) return true;
5295 if (jj_3R_36()) return true;
5296 return false;
5297 }
5298
5299 final private boolean jj_3R_213() {
5300 if (jj_3R_215()) return true;
5301 return false;
5302 }
5303
5304 final private boolean jj_3R_212() {
5305 if (jj_3R_214()) return true;
5306 return false;
5307 }
5308
5309 final private boolean jj_3R_202() {
5310 if (jj_scan_token(_DEFAULT)) return true;
5311 if (jj_scan_token(COLON)) return true;
5312 return false;
5313 }
5314
5315 final private boolean jj_3R_211() {
5316 Token xsp;
5317 xsp = jj_scanpos;
5318 if (jj_scan_token(87)) {
5319 jj_scanpos = xsp;
5320 if (jj_scan_token(86)) return true;
5321 }
5322 if (jj_3R_191()) return true;
5323 return false;
5324 }
5325
5326 final private boolean jj_3R_208() {
5327 Token xsp;
5328 xsp = jj_scanpos;
5329 if (jj_3R_211()) {
5330 jj_scanpos = xsp;
5331 if (jj_3R_212()) {
5332 jj_scanpos = xsp;
5333 if (jj_3R_213()) return true;
5334 }
5335 }
5336 return false;
5337 }
5338
5339 final private boolean jj_3R_201() {
5340 if (jj_scan_token(CASE)) return true;
5341 if (jj_3R_39()) return true;
5342 if (jj_scan_token(COLON)) return true;
5343 return false;
5344 }
5345
5346 final private boolean jj_3R_193() {
5347 Token xsp;
5348 xsp = jj_scanpos;
5349 if (jj_3R_201()) {
5350 jj_scanpos = xsp;
5351 if (jj_3R_202()) return true;
5352 }
5353 return false;
5354 }
5355
5356 final private boolean jj_3R_183() {
5357 if (jj_3R_193()) return true;
5358 Token xsp;
5359 while (true) {
5360 xsp = jj_scanpos;
5361 if (jj_3_29()) { jj_scanpos = xsp; break; }
5362 }
5363 return false;
5364 }
5365
5366 final private boolean jj_3R_207() {
5367 if (jj_scan_token(DECR)) return true;
5368 if (jj_3R_33()) return true;
5369 return false;
5370 }
5371
5372 final private boolean jj_3_1() {
5373 if (jj_3R_28()) return true;
5374 return false;
5375 }
5376
5377 final private boolean jj_3R_113() {
5378 if (jj_scan_token(SWITCH)) return true;
5379 if (jj_scan_token(LPAREN)) return true;
5380 if (jj_3R_39()) return true;
5381 if (jj_scan_token(RPAREN)) return true;
5382 if (jj_scan_token(LBRACE)) return true;
5383 Token xsp;
5384 while (true) {
5385 xsp = jj_scanpos;
5386 if (jj_3R_183()) { jj_scanpos = xsp; break; }
5387 }
5388 if (jj_scan_token(RBRACE)) return true;
5389 return false;
5390 }
5391
5392 final private boolean jj_3R_209() {
5393 Token xsp;
5394 xsp = jj_scanpos;
5395 if (jj_scan_token(104)) {
5396 jj_scanpos = xsp;
5397 if (jj_scan_token(105)) {
5398 jj_scanpos = xsp;
5399 if (jj_scan_token(111)) return true;
5400 }
5401 }
5402 if (jj_3R_191()) return true;
5403 return false;
5404 }
5405
5406 final private boolean jj_3R_206() {
5407 if (jj_scan_token(INCR)) return true;
5408 if (jj_3R_33()) return true;
5409 return false;
5410 }
5411
5412 final private boolean jj_3R_199() {
5413 if (jj_3R_208()) return true;
5414 return false;
5415 }
5416
5417 final private boolean jj_3R_198() {
5418 if (jj_3R_207()) return true;
5419 return false;
5420 }
5421
5422 final private boolean jj_3R_197() {
5423 if (jj_3R_206()) return true;
5424 return false;
5425 }
5426
5427 final private boolean jj_3R_196() {
5428 Token xsp;
5429 xsp = jj_scanpos;
5430 if (jj_scan_token(102)) {
5431 jj_scanpos = xsp;
5432 if (jj_scan_token(103)) return true;
5433 }
5434 if (jj_3R_191()) return true;
5435 return false;
5436 }
5437
5438 final private boolean jj_3R_191() {
5439 Token xsp;
5440 xsp = jj_scanpos;
5441 if (jj_3R_196()) {
5442 jj_scanpos = xsp;
5443 if (jj_3R_197()) {
5444 jj_scanpos = xsp;
5445 if (jj_3R_198()) {
5446 jj_scanpos = xsp;
5447 if (jj_3R_199()) return true;
5448 }
5449 }
5450 }
5451 return false;
5452 }
5453
5454 final private boolean jj_3R_44() {
5455 if (jj_scan_token(THROWS)) return true;
5456 if (jj_3R_76()) return true;
5457 return false;
5458 }
5459
5460 final private boolean jj_3R_112() {
5461 if (jj_3R_39()) return true;
5462 return false;
5463 }
5464
5465 final private boolean jj_3R_181() {
5466 if (jj_3R_191()) return true;
5467 Token xsp;
5468 while (true) {
5469 xsp = jj_scanpos;
5470 if (jj_3R_209()) { jj_scanpos = xsp; break; }
5471 }
5472 return false;
5473 }
5474
5475 final private boolean jj_3R_200() {
5476 Token xsp;
5477 xsp = jj_scanpos;
5478 if (jj_scan_token(102)) {
5479 jj_scanpos = xsp;
5480 if (jj_scan_token(103)) return true;
5481 }
5482 if (jj_3R_181()) return true;
5483 return false;
5484 }
5485
5486 final private boolean jj_3R_178() {
5487 if (jj_3R_181()) return true;
5488 Token xsp;
5489 while (true) {
5490 xsp = jj_scanpos;
5491 if (jj_3R_200()) { jj_scanpos = xsp; break; }
5492 }
5493 return false;
5494 }
5495
5496 final private boolean jj_3R_96() {
5497 if (jj_scan_token(FORMAL_COMMENT)) return true;
5498 return false;
5499 }
5500
5501 final private boolean jj_3R_192() {
5502 Token xsp;
5503 xsp = jj_scanpos;
5504 if (jj_scan_token(112)) {
5505 jj_scanpos = xsp;
5506 if (jj_scan_token(113)) {
5507 jj_scanpos = xsp;
5508 if (jj_scan_token(114)) {
5509 jj_scanpos = xsp;
5510 if (jj_scan_token(115)) {
5511 jj_scanpos = xsp;
5512 if (jj_scan_token(116)) {
5513 jj_scanpos = xsp;
5514 if (jj_scan_token(117)) return true;
5515 }
5516 }
5517 }
5518 }
5519 }
5520 if (jj_3R_178()) return true;
5521 return false;
5522 }
5523
5524 final private boolean jj_3R_171() {
5525 Token xsp;
5526 xsp = jj_scanpos;
5527 if (jj_scan_token(90)) {
5528 jj_scanpos = xsp;
5529 if (jj_scan_token(95)) return true;
5530 }
5531 if (jj_3R_166()) return true;
5532 return false;
5533 }
5534
5535 final private boolean jj_3R_170() {
5536 if (jj_3R_178()) return true;
5537 Token xsp;
5538 while (true) {
5539 xsp = jj_scanpos;
5540 if (jj_3R_192()) { jj_scanpos = xsp; break; }
5541 }
5542 return false;
5543 }
5544
5545 final private boolean jj_3R_52() {
5546 if (jj_3R_96()) return true;
5547 return false;
5548 }
5549
5550 final private boolean jj_3R_182() {
5551 Token xsp;
5552 xsp = jj_scanpos;
5553 if (jj_scan_token(84)) {
5554 jj_scanpos = xsp;
5555 if (jj_scan_token(85)) {
5556 jj_scanpos = xsp;
5557 if (jj_scan_token(82)) {
5558 jj_scanpos = xsp;
5559 if (jj_scan_token(83)) {
5560 jj_scanpos = xsp;
5561 if (jj_scan_token(91)) {
5562 jj_scanpos = xsp;
5563 if (jj_scan_token(92)) {
5564 jj_scanpos = xsp;
5565 if (jj_scan_token(93)) {
5566 jj_scanpos = xsp;
5567 if (jj_scan_token(94)) return true;
5568 }
5569 }
5570 }
5571 }
5572 }
5573 }
5574 }
5575 if (jj_3R_170()) return true;
5576 return false;
5577 }
5578
5579 final private boolean jj_3_27() {
5580 if (jj_3R_41()) return true;
5581 if (jj_3R_32()) return true;
5582 if (jj_scan_token(IDENTIFIER)) return true;
5583 return false;
5584 }
5585
5586 final private boolean jj_3R_51() {
5587 if (jj_3R_95()) return true;
5588 return false;
5589 }
5590
5591 final private boolean jj_3R_168() {
5592 if (jj_3R_170()) return true;
5593 Token xsp;
5594 while (true) {
5595 xsp = jj_scanpos;
5596 if (jj_3R_182()) { jj_scanpos = xsp; break; }
5597 }
5598 return false;
5599 }
5600
5601 final private boolean jj_3R_50() {
5602 if (jj_3R_94()) return true;
5603 return false;
5604 }
5605
5606 final private boolean jj_3_26() {
5607 if (jj_3R_41()) return true;
5608 if (jj_scan_token(IDENTIFIER)) return true;
5609 if (jj_3R_43()) return true;
5610 Token xsp;
5611 xsp = jj_scanpos;
5612 if (jj_3R_44()) jj_scanpos = xsp;
5613 if (jj_scan_token(LBRACE)) return true;
5614 return false;
5615 }
5616
5617 final private boolean jj_3R_179() {
5618 if (jj_scan_token(INSTANCEOF)) return true;
5619 if (jj_3R_32()) return true;
5620 return false;
5621 }
5622
5623 final private boolean jj_3_28() {
5624 if (jj_3R_45()) return true;
5625 return false;
5626 }
5627
5628 final private boolean jj_3R_166() {
5629 if (jj_3R_168()) return true;
5630 Token xsp;
5631 xsp = jj_scanpos;
5632 if (jj_3R_179()) jj_scanpos = xsp;
5633 return false;
5634 }
5635
5636 final private boolean jj_3_25() {
5637 if (jj_3R_41()) return true;
5638 if (jj_3R_42()) return true;
5639 if (jj_scan_token(IDENTIFIER)) return true;
5640 if (jj_scan_token(LPAREN)) return true;
5641 return false;
5642 }
5643
5644 final private boolean jj_3R_49() {
5645 if (jj_3R_93()) return true;
5646 if (jj_scan_token(SEMICOLON)) return true;
5647 return false;
5648 }
5649
5650 final private boolean jj_3_24() {
5651 if (jj_3R_41()) return true;
5652 Token xsp;
5653 xsp = jj_scanpos;
5654 if (jj_scan_token(13)) {
5655 jj_scanpos = xsp;
5656 if (jj_scan_token(37)) return true;
5657 }
5658 return false;
5659 }
5660
5661 final private boolean jj_3R_167() {
5662 if (jj_scan_token(XOR)) return true;
5663 if (jj_3R_161()) return true;
5664 return false;
5665 }
5666
5667 final private boolean jj_3R_48() {
5668 if (jj_3R_92()) return true;
5669 return false;
5670 }
5671
5672 final private boolean jj_3R_164() {
5673 if (jj_3R_166()) return true;
5674 Token xsp;
5675 while (true) {
5676 xsp = jj_scanpos;
5677 if (jj_3R_171()) { jj_scanpos = xsp; break; }
5678 }
5679 return false;
5680 }
5681
5682 final private boolean jj_3R_47() {
5683 if (jj_3R_92()) return true;
5684 return false;
5685 }
5686
5687 final private boolean jj_3R_169() {
5688 Token xsp;
5689 xsp = jj_scanpos;
5690 if (jj_scan_token(106)) {
5691 jj_scanpos = xsp;
5692 if (jj_scan_token(107)) return true;
5693 }
5694 if (jj_3R_164()) return true;
5695 return false;
5696 }
5697
5698 public ParserTokenManager token_source;
5699 JavaCharStream jj_input_stream;
5700 public Token token, jj_nt;
5701 private int jj_ntk;
5702 private Token jj_scanpos, jj_lastpos;
5703 private int jj_la;
5704 public boolean lookingAhead = false;
5705 private boolean jj_semLA;
5706
5707 public Parser(java.io.InputStream stream) {
5708 jj_input_stream = new JavaCharStream(stream, 1, 1);
5709 token_source = new ParserTokenManager(jj_input_stream);
5710 token = new Token();
5711 jj_ntk = -1;
5712 }
5713
5714 public void ReInit(java.io.InputStream stream) {
5715 jj_input_stream.ReInit(stream, 1, 1);
5716 token_source.ReInit(jj_input_stream);
5717 token = new Token();
5718 jj_ntk = -1;
5719 jjtree.reset();
5720 }
5721
5722 public Parser(java.io.Reader stream) {
5723 jj_input_stream = new JavaCharStream(stream, 1, 1);
5724 token_source = new ParserTokenManager(jj_input_stream);
5725 token = new Token();
5726 jj_ntk = -1;
5727 }
5728
5729 public void ReInit(java.io.Reader stream) {
5730 jj_input_stream.ReInit(stream, 1, 1);
5731 token_source.ReInit(jj_input_stream);
5732 token = new Token();
5733 jj_ntk = -1;
5734 jjtree.reset();
5735 }
5736
5737 public Parser(ParserTokenManager tm) {
5738 token_source = tm;
5739 token = new Token();
5740 jj_ntk = -1;
5741 }
5742
5743 public void ReInit(ParserTokenManager tm) {
5744 token_source = tm;
5745 token = new Token();
5746 jj_ntk = -1;
5747 jjtree.reset();
5748 }
5749
5750 final private Token jj_consume_token(int kind) throws ParseException {
5751 Token oldToken;
5752 if ((oldToken = token).next != null) token = token.next;
5753 else token = token.next = token_source.getNextToken();
5754 jj_ntk = -1;
5755 if (token.kind == kind) {
5756 return token;
5757 }
5758 token = oldToken;
5759 throw generateParseException();
5760 }
5761
5762 static private final class LookaheadSuccess extends java.lang.Error { }
5763 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
5764 final private boolean jj_scan_token(int kind) {
5765 if (jj_scanpos == jj_lastpos) {
5766 jj_la--;
5767 if (jj_scanpos.next == null) {
5768 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
5769 } else {
5770 jj_lastpos = jj_scanpos = jj_scanpos.next;
5771 }
5772 } else {
5773 jj_scanpos = jj_scanpos.next;
5774 }
5775 if (jj_scanpos.kind != kind) return true;
5776 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
5777 return false;
5778 }
5779
5780 final public Token getNextToken() {
5781 if (token.next != null) token = token.next;
5782 else token = token.next = token_source.getNextToken();
5783 jj_ntk = -1;
5784 return token;
5785 }
5786
5787 final public Token getToken(int index) {
5788 Token t = lookingAhead ? jj_scanpos : token;
5789 for (int i = 0; i < index; i++) {
5790 if (t.next != null) t = t.next;
5791 else t = t.next = token_source.getNextToken();
5792 }
5793 return t;
5794 }
5795
5796 final private int jj_ntk() {
5797 if ((jj_nt=token.next) == null)
5798 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
5799 else
5800 return (jj_ntk = jj_nt.kind);
5801 }
5802
5803 public ParseException generateParseException() {
5804 Token errortok = token.next;
5805 int line = errortok.beginLine, column = errortok.beginColumn;
5806 String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image;
5807 ParseException ex = new ParseException("Parse error at line " + line + ", column " + column + ". Encountered: " + mess);
5808 ex.currentToken = token;
5809 return ex;
5810 }
5811
5812 final public void enable_tracing() {
5813 }
5814
5815 final public void disable_tracing() {
5816 }
5817
5818 }