1
2 package cppast;
3
4 public final class Parser
5 protected JJTParserState jjtree = new JJTParserState();private final SymbolTable symbols = new SymbolTable();
6
7 private void jjtreeOpenNodeScope( final SimpleNode node )
8 {
9 node.openScope( getToken( 1 ), symbols.getCurrentScope() );
10 }
11
12 private void jjtreeCloseNodeScope( final SimpleNode node )
13 {
14 node.closeScope( getToken( 0 ) );
15 }
16
17 private void openScope( final String name )
18 {
19 symbols.openScope( name );
20 }
21
22 private void closeScope()
23 {
24 symbols.closeScope();
25 }
26
27 private void closeScopes()
28 {
29 symbols.closeScopes();
30 }
31
32 private void extendScope( final String name )
33 {
34 symbols.extend( name );
35 }
36
37 final public AstTranslationUnit translation_unit() throws ParseException {
38
39 AstTranslationUnit jjtn000 = new AstTranslationUnit(JJTTRANSLATIONUNIT);
40 boolean jjtc000 = true;
41 jjtree.openNodeScope(jjtn000);
42 jjtreeOpenNodeScope(jjtn000);
43 try {
44 label_1:
45 while (true) {
46 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
47 case LPARENTHESIS:
48 case SCOPE:
49 case SEMICOLON:
50 case AMPERSAND:
51 case STAR:
52 case TILDE:
53 case AUTO:
54 case BOOL:
55 case CHAR:
56 case CONST:
57 case DOUBLE:
58 case ENUM:
59 case EXPLICIT:
60 case EXTERN:
61 case FLOAT:
62 case FRIEND:
63 case INLINE:
64 case INT:
65 case LONG:
66 case MUTABLE:
67 case NAMESPACE:
68 case REGISTER:
69 case SHORT:
70 case SIGNED:
71 case STATIC:
72 case STRUCT:
73 case CLASS:
74 case TEMPLATE:
75 case TYPEDEF:
76 case TYPENAME:
77 case UNION:
78 case UNSIGNED:
79 case USING:
80 case VIRTUAL:
81 case VOID:
82 case VOLATILE:
83 case WCHAR_T:
84 case OPERATOR:
85 case ID:
86 ;
87 break;
88 default:
89 jj_la1[0] = jj_gen;
90 break label_1;
91 }
92 declaration();
93 }
94 jj_consume_token(0);
95 jjtree.closeNodeScope(jjtn000, true);
96 jjtc000 = false;
97 jjtreeCloseNodeScope(jjtn000);
98 closeScopes(); {if (true) return jjtn000;}
99 } catch (Throwable jjte000) {
100 if (jjtc000) {
101 jjtree.clearNodeScope(jjtn000);
102 jjtc000 = false;
103 } else {
104 jjtree.popNode();
105 }
106 if (jjte000 instanceof RuntimeException) {
107 {if (true) throw (RuntimeException)jjte000;}
108 }
109 if (jjte000 instanceof ParseException) {
110 {if (true) throw (ParseException)jjte000;}
111 }
112 {if (true) throw (Error)jjte000;}
113 } finally {
114 if (jjtc000) {
115 jjtree.closeNodeScope(jjtn000, true);
116 jjtreeCloseNodeScope(jjtn000);
117 }
118 }
119 throw new Error("Missing return statement in function");
120 }
121
122 final public void declaration() throws ParseException {
123 if (jj_2_1(2147483647)) {
124 template_declaration();
125 } else if (jj_2_2(2147483647)) {
126 conversion_function_decl_or_def();
127 } else if (jj_2_3(2147483647)) {
128 dtor_definition();
129 } else if (jj_2_4(2147483647)) {
130 ctor_definition();
131 } else if (jj_2_5(2147483647)) {
132 function_decl_or_def();
133 } else if (jj_2_6(2147483647)) {
134 AstDeclaration jjtn001 = new AstDeclaration(JJTDECLARATION);
135 boolean jjtc001 = true;
136 jjtree.openNodeScope(jjtn001);
137 jjtreeOpenNodeScope(jjtn001);
138 try {
139 block_declaration();
140 } catch (Throwable jjte001) {
141 if (jjtc001) {
142 jjtree.clearNodeScope(jjtn001);
143 jjtc001 = false;
144 } else {
145 jjtree.popNode();
146 }
147 if (jjte001 instanceof RuntimeException) {
148 {if (true) throw (RuntimeException)jjte001;}
149 }
150 if (jjte001 instanceof ParseException) {
151 {if (true) throw (ParseException)jjte001;}
152 }
153 {if (true) throw (Error)jjte001;}
154 } finally {
155 if (jjtc001) {
156 jjtree.closeNodeScope(jjtn001, true);
157 jjtreeCloseNodeScope(jjtn001);
158 }
159 }
160 } else if (jj_2_7(2147483647)) {
161 namespace_definition();
162 } else {
163 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
164 case EXTERN:
165 linkage_specification();
166 break;
167 case SEMICOLON:
168 jj_consume_token(SEMICOLON);
169 break;
170 default:
171 jj_la1[1] = jj_gen;
172 jj_consume_token(-1);
173 throw new ParseException();
174 }
175 }
176 }
177
178 final public void template_declaration() throws ParseException {
179 template_head();
180 declaration();
181 }
182
183 final public void function_decl_or_def() throws ParseException {
184 if (jj_2_8(2147483647)) {
185 AstFunctionDeclaration jjtn001 = new AstFunctionDeclaration(JJTFUNCTIONDECLARATION);
186 boolean jjtc001 = true;
187 jjtree.openNodeScope(jjtn001);
188 jjtreeOpenNodeScope(jjtn001);
189 try {
190 function();
191 jj_consume_token(SEMICOLON);
192 } catch (Throwable jjte001) {
193 if (jjtc001) {
194 jjtree.clearNodeScope(jjtn001);
195 jjtc001 = false;
196 } else {
197 jjtree.popNode();
198 }
199 if (jjte001 instanceof RuntimeException) {
200 {if (true) throw (RuntimeException)jjte001;}
201 }
202 if (jjte001 instanceof ParseException) {
203 {if (true) throw (ParseException)jjte001;}
204 }
205 {if (true) throw (Error)jjte001;}
206 } finally {
207 if (jjtc001) {
208 jjtree.closeNodeScope(jjtn001, true);
209 jjtreeCloseNodeScope(jjtn001);
210 }
211 }
212 } else {
213 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
214 case LPARENTHESIS:
215 case SCOPE:
216 case AMPERSAND:
217 case STAR:
218 case AUTO:
219 case BOOL:
220 case CHAR:
221 case CONST:
222 case DOUBLE:
223 case ENUM:
224 case EXTERN:
225 case FLOAT:
226 case FRIEND:
227 case INLINE:
228 case INT:
229 case LONG:
230 case MUTABLE:
231 case REGISTER:
232 case SHORT:
233 case SIGNED:
234 case STATIC:
235 case STRUCT:
236 case CLASS:
237 case TEMPLATE:
238 case TYPEDEF:
239 case TYPENAME:
240 case UNION:
241 case UNSIGNED:
242 case VIRTUAL:
243 case VOID:
244 case VOLATILE:
245 case WCHAR_T:
246 case OPERATOR:
247 case ID:
248 AstFunctionDefinition jjtn003 = new AstFunctionDefinition(JJTFUNCTIONDEFINITION);
249 boolean jjtc003 = true;
250 jjtree.openNodeScope(jjtn003);
251 jjtreeOpenNodeScope(jjtn003);
252 try {
253 function();
254 AstFunctionBody jjtn002 = new AstFunctionBody(JJTFUNCTIONBODY);
255 boolean jjtc002 = true;
256 jjtree.openNodeScope(jjtn002);
257 jjtreeOpenNodeScope(jjtn002);
258 try {
259 compound_statement();
260 } catch (Throwable jjte002) {
261 if (jjtc002) {
262 jjtree.clearNodeScope(jjtn002);
263 jjtc002 = false;
264 } else {
265 jjtree.popNode();
266 }
267 if (jjte002 instanceof RuntimeException) {
268 {if (true) throw (RuntimeException)jjte002;}
269 }
270 if (jjte002 instanceof ParseException) {
271 {if (true) throw (ParseException)jjte002;}
272 }
273 {if (true) throw (Error)jjte002;}
274 } finally {
275 if (jjtc002) {
276 jjtree.closeNodeScope(jjtn002, true);
277 jjtreeCloseNodeScope(jjtn002);
278 }
279 }
280 } catch (Throwable jjte003) {
281 if (jjtc003) {
282 jjtree.clearNodeScope(jjtn003);
283 jjtc003 = false;
284 } else {
285 jjtree.popNode();
286 }
287 if (jjte003 instanceof RuntimeException) {
288 {if (true) throw (RuntimeException)jjte003;}
289 }
290 if (jjte003 instanceof ParseException) {
291 {if (true) throw (ParseException)jjte003;}
292 }
293 {if (true) throw (Error)jjte003;}
294 } finally {
295 if (jjtc003) {
296 jjtree.closeNodeScope(jjtn003, true);
297 jjtreeCloseNodeScope(jjtn003);
298 }
299 }
300 break;
301 default:
302 jj_la1[2] = jj_gen;
303 jj_consume_token(-1);
304 throw new ParseException();
305 }
306 }
307 }
308
309 final public void function() throws ParseException {
310 if (jj_2_9(3)) {
311 declaration_specifiers();
312 } else {
313 ;
314 }
315 function_declarator();
316 }
317
318 final public void conversion_function_decl_or_def() throws ParseException {
319 if (jj_2_10(2147483647)) {
320 AstFunctionDeclaration jjtn001 = new AstFunctionDeclaration(JJTFUNCTIONDECLARATION);
321 boolean jjtc001 = true;
322 jjtree.openNodeScope(jjtn001);
323 jjtreeOpenNodeScope(jjtn001);
324 try {
325 conversion_function();
326 jj_consume_token(SEMICOLON);
327 } catch (Throwable jjte001) {
328 if (jjtc001) {
329 jjtree.clearNodeScope(jjtn001);
330 jjtc001 = false;
331 } else {
332 jjtree.popNode();
333 }
334 if (jjte001 instanceof RuntimeException) {
335 {if (true) throw (RuntimeException)jjte001;}
336 }
337 if (jjte001 instanceof ParseException) {
338 {if (true) throw (ParseException)jjte001;}
339 }
340 {if (true) throw (Error)jjte001;}
341 } finally {
342 if (jjtc001) {
343 jjtree.closeNodeScope(jjtn001, true);
344 jjtreeCloseNodeScope(jjtn001);
345 }
346 }
347 } else {
348 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
349 case SCOPE:
350 case AUTO:
351 case CONST:
352 case EXTERN:
353 case FRIEND:
354 case INLINE:
355 case MUTABLE:
356 case REGISTER:
357 case STATIC:
358 case TEMPLATE:
359 case TYPEDEF:
360 case TYPENAME:
361 case VIRTUAL:
362 case VOLATILE:
363 case OPERATOR:
364 case ID:
365 AstFunctionDefinition jjtn003 = new AstFunctionDefinition(JJTFUNCTIONDEFINITION);
366 boolean jjtc003 = true;
367 jjtree.openNodeScope(jjtn003);
368 jjtreeOpenNodeScope(jjtn003);
369 try {
370 conversion_function();
371 AstFunctionBody jjtn002 = new AstFunctionBody(JJTFUNCTIONBODY);
372 boolean jjtc002 = true;
373 jjtree.openNodeScope(jjtn002);
374 jjtreeOpenNodeScope(jjtn002);
375 try {
376 compound_statement();
377 } catch (Throwable jjte002) {
378 if (jjtc002) {
379 jjtree.clearNodeScope(jjtn002);
380 jjtc002 = false;
381 } else {
382 jjtree.popNode();
383 }
384 if (jjte002 instanceof RuntimeException) {
385 {if (true) throw (RuntimeException)jjte002;}
386 }
387 if (jjte002 instanceof ParseException) {
388 {if (true) throw (ParseException)jjte002;}
389 }
390 {if (true) throw (Error)jjte002;}
391 } finally {
392 if (jjtc002) {
393 jjtree.closeNodeScope(jjtn002, true);
394 jjtreeCloseNodeScope(jjtn002);
395 }
396 }
397 } catch (Throwable jjte003) {
398 if (jjtc003) {
399 jjtree.clearNodeScope(jjtn003);
400 jjtc003 = false;
401 } else {
402 jjtree.popNode();
403 }
404 if (jjte003 instanceof RuntimeException) {
405 {if (true) throw (RuntimeException)jjte003;}
406 }
407 if (jjte003 instanceof ParseException) {
408 {if (true) throw (ParseException)jjte003;}
409 }
410 {if (true) throw (Error)jjte003;}
411 } finally {
412 if (jjtc003) {
413 jjtree.closeNodeScope(jjtn003, true);
414 jjtreeCloseNodeScope(jjtn003);
415 }
416 }
417 break;
418 default:
419 jj_la1[3] = jj_gen;
420 jj_consume_token(-1);
421 throw new ParseException();
422 }
423 }
424 }
425
426 final public void conversion_function() throws ParseException {
427 label_2:
428 while (true) {
429 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
430 case AUTO:
431 case CONST:
432 case EXTERN:
433 case FRIEND:
434 case INLINE:
435 case MUTABLE:
436 case REGISTER:
437 case STATIC:
438 case TYPEDEF:
439 case TYPENAME:
440 case VIRTUAL:
441 case VOLATILE:
442 ;
443 break;
444 default:
445 jj_la1[4] = jj_gen;
446 break label_2;
447 }
448 type_modifiers();
449 }
450 operator_id();
451 function_parameters();
452 cv_qualifier_seq();
453 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
454 case THROW:
455 exception_spec();
456 break;
457 default:
458 jj_la1[5] = jj_gen;
459 ;
460 }
461 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
462 case ASSIGNEQUAL:
463 pure_specifier();
464 break;
465 default:
466 jj_la1[6] = jj_gen;
467 ;
468 }
469 }
470
471 final public void function_parameters() throws ParseException {
472
473 AstFunctionParameters jjtn000 = new AstFunctionParameters(JJTFUNCTIONPARAMETERS);
474 boolean jjtc000 = true;
475 jjtree.openNodeScope(jjtn000);
476 jjtreeOpenNodeScope(jjtn000);
477 try {
478 jj_consume_token(LPARENTHESIS);
479 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
480 case SCOPE:
481 case ELLIPSIS:
482 case AUTO:
483 case BOOL:
484 case CHAR:
485 case CONST:
486 case DOUBLE:
487 case ENUM:
488 case EXTERN:
489 case FLOAT:
490 case FRIEND:
491 case INLINE:
492 case INT:
493 case LONG:
494 case MUTABLE:
495 case REGISTER:
496 case SHORT:
497 case SIGNED:
498 case STATIC:
499 case STRUCT:
500 case CLASS:
501 case TEMPLATE:
502 case TYPEDEF:
503 case TYPENAME:
504 case UNION:
505 case UNSIGNED:
506 case VIRTUAL:
507 case VOID:
508 case VOLATILE:
509 case WCHAR_T:
510 case ID:
511 parameter_list();
512 break;
513 default:
514 jj_la1[7] = jj_gen;
515 ;
516 }
517 jj_consume_token(RPARENTHESIS);
518 } catch (Throwable jjte000) {
519 if (jjtc000) {
520 jjtree.clearNodeScope(jjtn000);
521 jjtc000 = false;
522 } else {
523 jjtree.popNode();
524 }
525 if (jjte000 instanceof RuntimeException) {
526 {if (true) throw (RuntimeException)jjte000;}
527 }
528 if (jjte000 instanceof ParseException) {
529 {if (true) throw (ParseException)jjte000;}
530 }
531 {if (true) throw (Error)jjte000;}
532 } finally {
533 if (jjtc000) {
534 jjtree.closeNodeScope(jjtn000, true);
535 jjtreeCloseNodeScope(jjtn000);
536 }
537 }
538 }
539
540 final public void parameter_list() throws ParseException {
541 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
542 case SCOPE:
543 case AUTO:
544 case BOOL:
545 case CHAR:
546 case CONST:
547 case DOUBLE:
548 case ENUM:
549 case EXTERN:
550 case FLOAT:
551 case FRIEND:
552 case INLINE:
553 case INT:
554 case LONG:
555 case MUTABLE:
556 case REGISTER:
557 case SHORT:
558 case SIGNED:
559 case STATIC:
560 case STRUCT:
561 case CLASS:
562 case TEMPLATE:
563 case TYPEDEF:
564 case TYPENAME:
565 case UNION:
566 case UNSIGNED:
567 case VIRTUAL:
568 case VOID:
569 case VOLATILE:
570 case WCHAR_T:
571 case ID:
572 parameter_declaration_list();
573 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
574 case COMMA:
575 jj_consume_token(COMMA);
576 jj_consume_token(ELLIPSIS);
577 break;
578 default:
579 jj_la1[8] = jj_gen;
580 ;
581 }
582 break;
583 case ELLIPSIS:
584 jj_consume_token(ELLIPSIS);
585 break;
586 default:
587 jj_la1[9] = jj_gen;
588 jj_consume_token(-1);
589 throw new ParseException();
590 }
591 }
592
593 final public void operator_id() throws ParseException {
594
595 AstFunctionName jjtn000 = new AstFunctionName(JJTFUNCTIONNAME);
596 boolean jjtc000 = true;
597 jjtree.openNodeScope(jjtn000);
598 jjtreeOpenNodeScope(jjtn000);
599 try {
600 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
601 case SCOPE:
602 case TEMPLATE:
603 case ID:
604 scope_override();
605 break;
606 default:
607 jj_la1[10] = jj_gen;
608 ;
609 }
610 jj_consume_token(OPERATOR);
611 declaration_specifiers();
612 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
613 case AMPERSAND:
614 case STAR:
615 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
616 case STAR:
617 jj_consume_token(STAR);
618 cv_qualifier_seq();
619 break;
620 case AMPERSAND:
621 jj_consume_token(AMPERSAND);
622 break;
623 default:
624 jj_la1[11] = jj_gen;
625 jj_consume_token(-1);
626 throw new ParseException();
627 }
628 break;
629 default:
630 jj_la1[12] = jj_gen;
631 ;
632 }
633 } catch (Throwable jjte000) {
634 if (jjtc000) {
635 jjtree.clearNodeScope(jjtn000);
636 jjtc000 = false;
637 } else {
638 jjtree.popNode();
639 }
640 if (jjte000 instanceof RuntimeException) {
641 {if (true) throw (RuntimeException)jjte000;}
642 }
643 if (jjte000 instanceof ParseException) {
644 {if (true) throw (ParseException)jjte000;}
645 }
646 {if (true) throw (Error)jjte000;}
647 } finally {
648 if (jjtc000) {
649 jjtree.closeNodeScope(jjtn000, true);
650 jjtreeCloseNodeScope(jjtn000);
651 }
652 }
653 }
654
655 final public void linkage_specification() throws ParseException {
656 jj_consume_token(EXTERN);
657 jj_consume_token(STRING);
658 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
659 case LCURLYBRACE:
660 jj_consume_token(LCURLYBRACE);
661 label_3:
662 while (true) {
663 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
664 case LPARENTHESIS:
665 case SCOPE:
666 case SEMICOLON:
667 case AMPERSAND:
668 case STAR:
669 case TILDE:
670 case AUTO:
671 case BOOL:
672 case CHAR:
673 case CONST:
674 case DOUBLE:
675 case ENUM:
676 case EXPLICIT:
677 case EXTERN:
678 case FLOAT:
679 case FRIEND:
680 case INLINE:
681 case INT:
682 case LONG:
683 case MUTABLE:
684 case NAMESPACE:
685 case REGISTER:
686 case SHORT:
687 case SIGNED:
688 case STATIC:
689 case STRUCT:
690 case CLASS:
691 case TEMPLATE:
692 case TYPEDEF:
693 case TYPENAME:
694 case UNION:
695 case UNSIGNED:
696 case USING:
697 case VIRTUAL:
698 case VOID:
699 case VOLATILE:
700 case WCHAR_T:
701 case OPERATOR:
702 case ID:
703 ;
704 break;
705 default:
706 jj_la1[13] = jj_gen;
707 break label_3;
708 }
709 declaration();
710 }
711 jj_consume_token(RCURLYBRACE);
712 if (jj_2_11(2147483647)) {
713 jj_consume_token(SEMICOLON);
714 } else {
715 ;
716 }
717 break;
718 case LPARENTHESIS:
719 case SCOPE:
720 case SEMICOLON:
721 case AMPERSAND:
722 case STAR:
723 case TILDE:
724 case AUTO:
725 case BOOL:
726 case CHAR:
727 case CONST:
728 case DOUBLE:
729 case ENUM:
730 case EXPLICIT:
731 case EXTERN:
732 case FLOAT:
733 case FRIEND:
734 case INLINE:
735 case INT:
736 case LONG:
737 case MUTABLE:
738 case NAMESPACE:
739 case REGISTER:
740 case SHORT:
741 case SIGNED:
742 case STATIC:
743 case STRUCT:
744 case CLASS:
745 case TEMPLATE:
746 case TYPEDEF:
747 case TYPENAME:
748 case UNION:
749 case UNSIGNED:
750 case USING:
751 case VIRTUAL:
752 case VOID:
753 case VOLATILE:
754 case WCHAR_T:
755 case OPERATOR:
756 case ID:
757 declaration();
758 break;
759 default:
760 jj_la1[14] = jj_gen;
761 jj_consume_token(-1);
762 throw new ParseException();
763 }
764 }
765
766 final public void using_directive() throws ParseException {
767 Token token;
768 String name = "";
769 jj_consume_token(USING);
770 jj_consume_token(NAMESPACE);
771 if (jj_2_12(2147483647)) {
772 name = scope_override();
773 } else {
774 ;
775 }
776 token = jj_consume_token(ID);
777 jj_consume_token(SEMICOLON);
778 extendScope( name + token.image );
779 }
780
781 final public void using_declaration() throws ParseException {
782 jj_consume_token(USING);
783 qualified_type();
784 jj_consume_token(SEMICOLON);
785 }
786
787 final public void namespace_definition() throws ParseException {
788
789 AstNamespaceDefinition jjtn000 = new AstNamespaceDefinition(JJTNAMESPACEDEFINITION);
790 boolean jjtc000 = true;
791 jjtree.openNodeScope(jjtn000);
792 jjtreeOpenNodeScope(jjtn000);Token token;
793 String name = "`anonymous-namespace'";
794 try {
795 jj_consume_token(NAMESPACE);
796 if (jj_2_14(2)) {
797 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
798 case ID:
799 token = jj_consume_token(ID);
800 name = token.image;
801 break;
802 default:
803 jj_la1[15] = jj_gen;
804 ;
805 }
806 jj_consume_token(LCURLYBRACE);
807 openScope( name );
808 label_4:
809 while (true) {
810 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
811 case LPARENTHESIS:
812 case SCOPE:
813 case SEMICOLON:
814 case AMPERSAND:
815 case STAR:
816 case TILDE:
817 case AUTO:
818 case BOOL:
819 case CHAR:
820 case CONST:
821 case DOUBLE:
822 case ENUM:
823 case EXPLICIT:
824 case EXTERN:
825 case FLOAT:
826 case FRIEND:
827 case INLINE:
828 case INT:
829 case LONG:
830 case MUTABLE:
831 case NAMESPACE:
832 case REGISTER:
833 case SHORT:
834 case SIGNED:
835 case STATIC:
836 case STRUCT:
837 case CLASS:
838 case TEMPLATE:
839 case TYPEDEF:
840 case TYPENAME:
841 case UNION:
842 case UNSIGNED:
843 case USING:
844 case VIRTUAL:
845 case VOID:
846 case VOLATILE:
847 case WCHAR_T:
848 case OPERATOR:
849 case ID:
850 ;
851 break;
852 default:
853 jj_la1[16] = jj_gen;
854 break label_4;
855 }
856 declaration();
857 }
858 jj_consume_token(RCURLYBRACE);
859 jjtree.closeNodeScope(jjtn000, true);
860 jjtc000 = false;
861 jjtreeCloseNodeScope(jjtn000);
862 closeScope();
863 } else {
864 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
865 case ID:
866 jj_consume_token(ID);
867 jj_consume_token(ASSIGNEQUAL);
868 if (jj_2_13(2147483647)) {
869 scope_override();
870 } else {
871 ;
872 }
873 jj_consume_token(ID);
874 jj_consume_token(SEMICOLON);
875 break;
876 default:
877 jj_la1[17] = jj_gen;
878 jj_consume_token(-1);
879 throw new ParseException();
880 }
881 }
882 } catch (Throwable jjte000) {
883 if (jjtc000) {
884 jjtree.clearNodeScope(jjtn000);
885 jjtc000 = false;
886 } else {
887 jjtree.popNode();
888 }
889 if (jjte000 instanceof RuntimeException) {
890 {if (true) throw (RuntimeException)jjte000;}
891 }
892 if (jjte000 instanceof ParseException) {
893 {if (true) throw (ParseException)jjte000;}
894 }
895 {if (true) throw (Error)jjte000;}
896 } finally {
897 if (jjtc000) {
898 jjtree.closeNodeScope(jjtn000, true);
899 jjtreeCloseNodeScope(jjtn000);
900 }
901 }
902 }
903
904 final public void declaration_specifiers() throws ParseException {
905 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
906 case AUTO:
907 case CONST:
908 case EXTERN:
909 case FRIEND:
910 case INLINE:
911 case MUTABLE:
912 case REGISTER:
913 case STATIC:
914 case TYPEDEF:
915 case TYPENAME:
916 case VIRTUAL:
917 case VOLATILE:
918 label_5:
919 while (true) {
920 type_modifiers();
921 if (jj_2_15(2147483647)) {
922 ;
923 } else {
924 break label_5;
925 }
926 }
927 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
928 case BOOL:
929 case CHAR:
930 case DOUBLE:
931 case FLOAT:
932 case INT:
933 case LONG:
934 case SHORT:
935 case SIGNED:
936 case UNSIGNED:
937 case VOID:
938 case WCHAR_T:
939 label_6:
940 while (true) {
941 builtin_type_specifier();
942 if (jj_2_16(2147483647)) {
943 ;
944 } else {
945 break label_6;
946 }
947 }
948 break;
949 case SCOPE:
950 case ENUM:
951 case STRUCT:
952 case CLASS:
953 case TEMPLATE:
954 case UNION:
955 case ID:
956 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
957 case STRUCT:
958 case CLASS:
959 case UNION:
960 class_specifier();
961 break;
962 case ENUM:
963 enum_specifier();
964 break;
965 case SCOPE:
966 case TEMPLATE:
967 case ID:
968 qualified_type();
969 break;
970 default:
971 jj_la1[18] = jj_gen;
972 jj_consume_token(-1);
973 throw new ParseException();
974 }
975 break;
976 default:
977 jj_la1[19] = jj_gen;
978 jj_consume_token(-1);
979 throw new ParseException();
980 }
981 label_7:
982 while (true) {
983 if (jj_2_17(2147483647)) {
984 ;
985 } else {
986 break label_7;
987 }
988 type_modifiers();
989 }
990 break;
991 case BOOL:
992 case CHAR:
993 case DOUBLE:
994 case FLOAT:
995 case INT:
996 case LONG:
997 case SHORT:
998 case SIGNED:
999 case UNSIGNED:
1000 case VOID:
1001 case WCHAR_T:
1002 label_8:
1003 while (true) {
1004 builtin_type_specifier();
1005 if (jj_2_18(2147483647)) {
1006 ;
1007 } else {
1008 break label_8;
1009 }
1010 }
1011 label_9:
1012 while (true) {
1013 if (jj_2_19(2147483647)) {
1014 ;
1015 } else {
1016 break label_9;
1017 }
1018 type_modifiers();
1019 }
1020 break;
1021 case SCOPE:
1022 case ENUM:
1023 case STRUCT:
1024 case CLASS:
1025 case TEMPLATE:
1026 case UNION:
1027 case ID:
1028 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1029 case STRUCT:
1030 case CLASS:
1031 case UNION:
1032 class_specifier();
1033 break;
1034 case ENUM:
1035 enum_specifier();
1036 break;
1037 case SCOPE:
1038 case TEMPLATE:
1039 case ID:
1040 qualified_type();
1041 break;
1042 default:
1043 jj_la1[20] = jj_gen;
1044 jj_consume_token(-1);
1045 throw new ParseException();
1046 }
1047 label_10:
1048 while (true) {
1049 if (jj_2_20(2147483647)) {
1050 ;
1051 } else {
1052 break label_10;
1053 }
1054 type_modifiers();
1055 }
1056 break;
1057 default:
1058 jj_la1[21] = jj_gen;
1059 jj_consume_token(-1);
1060 throw new ParseException();
1061 }
1062 }
1063
1064 final public void type_modifiers() throws ParseException {
1065 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1066 case AUTO:
1067 case EXTERN:
1068 case REGISTER:
1069 case STATIC:
1070 case TYPEDEF:
1071 storage_class_specifier();
1072 break;
1073 case CONST:
1074 case MUTABLE:
1075 case TYPENAME:
1076 case VOLATILE:
1077 type_qualifier();
1078 break;
1079 case INLINE:
1080 jj_consume_token(INLINE);
1081 break;
1082 case VIRTUAL:
1083 jj_consume_token(VIRTUAL);
1084 break;
1085 case FRIEND:
1086 jj_consume_token(FRIEND);
1087 break;
1088 default:
1089 jj_la1[22] = jj_gen;
1090 jj_consume_token(-1);
1091 throw new ParseException();
1092 }
1093 }
1094
1095 final public void storage_class_specifier() throws ParseException {
1096 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1097 case AUTO:
1098 jj_consume_token(AUTO);
1099 break;
1100 case REGISTER:
1101 jj_consume_token(REGISTER);
1102 break;
1103 case STATIC:
1104 jj_consume_token(STATIC);
1105 break;
1106 case EXTERN:
1107 jj_consume_token(EXTERN);
1108 break;
1109 case TYPEDEF:
1110 jj_consume_token(TYPEDEF);
1111 break;
1112 default:
1113 jj_la1[23] = jj_gen;
1114 jj_consume_token(-1);
1115 throw new ParseException();
1116 }
1117 }
1118
1119 final public void type_qualifier() throws ParseException {
1120 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1121 case CONST:
1122 jj_consume_token(CONST);
1123 break;
1124 case VOLATILE:
1125 jj_consume_token(VOLATILE);
1126 break;
1127 case TYPENAME:
1128 jj_consume_token(TYPENAME);
1129 break;
1130 case MUTABLE:
1131 jj_consume_token(MUTABLE);
1132 break;
1133 default:
1134 jj_la1[24] = jj_gen;
1135 jj_consume_token(-1);
1136 throw new ParseException();
1137 }
1138 }
1139
1140 final public void builtin_type_specifier() throws ParseException {
1141 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1142 case VOID:
1143 jj_consume_token(VOID);
1144 break;
1145 case CHAR:
1146 jj_consume_token(CHAR);
1147 break;
1148 case WCHAR_T:
1149 jj_consume_token(WCHAR_T);
1150 break;
1151 case SHORT:
1152 jj_consume_token(SHORT);
1153 break;
1154 case INT:
1155 jj_consume_token(INT);
1156 break;
1157 case LONG:
1158 jj_consume_token(LONG);
1159 break;
1160 case FLOAT:
1161 jj_consume_token(FLOAT);
1162 break;
1163 case DOUBLE:
1164 jj_consume_token(DOUBLE);
1165 break;
1166 case BOOL:
1167 jj_consume_token(BOOL);
1168 break;
1169 case SIGNED:
1170 jj_consume_token(SIGNED);
1171 break;
1172 case UNSIGNED:
1173 jj_consume_token(UNSIGNED);
1174 break;
1175 default:
1176 jj_la1[25] = jj_gen;
1177 jj_consume_token(-1);
1178 throw new ParseException();
1179 }
1180 }
1181
1182 final public void scope_override_lookahead() throws ParseException {
1183 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1184 case SCOPE:
1185 jj_consume_token(SCOPE);
1186 break;
1187 case TEMPLATE:
1188 case ID:
1189 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1190 case TEMPLATE:
1191 jj_consume_token(TEMPLATE);
1192 break;
1193 default:
1194 jj_la1[26] = jj_gen;
1195 ;
1196 }
1197 jj_consume_token(ID);
1198 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1199 case LESSTHAN:
1200 template_argument_list();
1201 break;
1202 default:
1203 jj_la1[27] = jj_gen;
1204 ;
1205 }
1206 jj_consume_token(SCOPE);
1207 break;
1208 default:
1209 jj_la1[28] = jj_gen;
1210 jj_consume_token(-1);
1211 throw new ParseException();
1212 }
1213 }
1214
1215 final public String scope_override() throws ParseException {
1216 String name = "";
1217 Token t;
1218 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1219 case SCOPE:
1220 jj_consume_token(SCOPE);
1221 name += "::";
1222 label_11:
1223 while (true) {
1224 if (jj_2_21(2147483647)) {
1225 ;
1226 } else {
1227 break label_11;
1228 }
1229 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1230 case TEMPLATE:
1231 jj_consume_token(TEMPLATE);
1232 break;
1233 default:
1234 jj_la1[29] = jj_gen;
1235 ;
1236 }
1237 t = jj_consume_token(ID);
1238 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1239 case LESSTHAN:
1240 template_argument_list();
1241 break;
1242 default:
1243 jj_la1[30] = jj_gen;
1244 ;
1245 }
1246 jj_consume_token(SCOPE);
1247 name += t.image + "::";
1248 }
1249 break;
1250 case TEMPLATE:
1251 case ID:
1252 label_12:
1253 while (true) {
1254 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1255 case TEMPLATE:
1256 jj_consume_token(TEMPLATE);
1257 break;
1258 default:
1259 jj_la1[31] = jj_gen;
1260 ;
1261 }
1262 t = jj_consume_token(ID);
1263 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1264 case LESSTHAN:
1265 template_argument_list();
1266 break;
1267 default:
1268 jj_la1[32] = jj_gen;
1269 ;
1270 }
1271 jj_consume_token(SCOPE);
1272 name += t.image + "::";
1273 if (jj_2_22(2147483647)) {
1274 ;
1275 } else {
1276 break label_12;
1277 }
1278 }
1279 break;
1280 default:
1281 jj_la1[33] = jj_gen;
1282 jj_consume_token(-1);
1283 throw new ParseException();
1284 }
1285 {if (true) return name;}
1286 throw new Error("Missing return statement in function");
1287 }
1288
1289 final public void qualified_id() throws ParseException {
1290 if (jj_2_23(2147483647)) {
1291 scope_override();
1292 } else {
1293 ;
1294 }
1295 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1296 case ID:
1297 jj_consume_token(ID);
1298 if (jj_2_24(2147483647)) {
1299 template_argument_list();
1300 } else {
1301 ;
1302 }
1303 break;
1304 case OPERATOR:
1305 jj_consume_token(OPERATOR);
1306 operator();
1307 break;
1308 default:
1309 jj_la1[34] = jj_gen;
1310 jj_consume_token(-1);
1311 throw new ParseException();
1312 }
1313 }
1314
1315 final public void qualified_type() throws ParseException {
1316 if (jj_2_25(2147483647)) {
1317 scope_override();
1318 } else {
1319 ;
1320 }
1321 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1322 case TEMPLATE:
1323 jj_consume_token(TEMPLATE);
1324 break;
1325 default:
1326 jj_la1[35] = jj_gen;
1327 ;
1328 }
1329 jj_consume_token(ID);
1330 if (jj_2_26(2147483647)) {
1331 template_argument_list();
1332 } else {
1333 ;
1334 }
1335 }
1336
1337 final public void init_declarator_list() throws ParseException {
1338 init_declarator();
1339 label_13:
1340 while (true) {
1341 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1342 case COMMA:
1343 ;
1344 break;
1345 default:
1346 jj_la1[36] = jj_gen;
1347 break label_13;
1348 }
1349 jj_consume_token(COMMA);
1350 init_declarator();
1351 }
1352 }
1353
1354 final public void init_declarator() throws ParseException {
1355 declarator();
1356 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1357 case LPARENTHESIS:
1358 case ASSIGNEQUAL:
1359 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1360 case ASSIGNEQUAL:
1361 jj_consume_token(ASSIGNEQUAL);
1362 initializer();
1363 break;
1364 case LPARENTHESIS:
1365 jj_consume_token(LPARENTHESIS);
1366 expression_list();
1367 jj_consume_token(RPARENTHESIS);
1368 break;
1369 default:
1370 jj_la1[37] = jj_gen;
1371 jj_consume_token(-1);
1372 throw new ParseException();
1373 }
1374 break;
1375 default:
1376 jj_la1[38] = jj_gen;
1377 ;
1378 }
1379 }
1380
1381 final public void initializer() throws ParseException {
1382 if (jj_2_27(3)) {
1383 jj_consume_token(LCURLYBRACE);
1384 label_14:
1385 while (true) {
1386 initializer();
1387 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1388 case COMMA:
1389 jj_consume_token(COMMA);
1390 break;
1391 default:
1392 jj_la1[39] = jj_gen;
1393 ;
1394 }
1395 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1396 case LCURLYBRACE:
1397 case LPARENTHESIS:
1398 case SCOPE:
1399 case AMPERSAND:
1400 case PLUS:
1401 case MINUS:
1402 case STAR:
1403 case PLUSPLUS:
1404 case MINUSMINUS:
1405 case TILDE:
1406 case NOT:
1407 case BOOL:
1408 case CHAR:
1409 case DELETE:
1410 case DOUBLE:
1411 case FLOAT:
1412 case INT:
1413 case LONG:
1414 case NEW:
1415 case SHORT:
1416 case SIGNED:
1417 case SIZEOF:
1418 case TEMPLATE:
1419 case THIS:
1420 case TYPEID:
1421 case UNSIGNED:
1422 case VOID:
1423 case WCHAR_T:
1424 case OPERATOR:
1425 case TRUETOK:
1426 case FALSETOK:
1427 case THROW:
1428 case OCTALINT:
1429 case OCTALLONG:
1430 case UNSIGNED_OCTALINT:
1431 case UNSIGNED_OCTALLONG:
1432 case DECIMALINT:
1433 case DECIMALLONG:
1434 case UNSIGNED_DECIMALINT:
1435 case UNSIGNED_DECIMALLONG:
1436 case HEXADECIMALINT:
1437 case HEXADECIMALLONG:
1438 case UNSIGNED_HEXADECIMALINT:
1439 case UNSIGNED_HEXADECIMALLONG:
1440 case FLOATONE:
1441 case FLOATTWO:
1442 case CHARACTER:
1443 case STRING:
1444 case ID:
1445 ;
1446 break;
1447 default:
1448 jj_la1[40] = jj_gen;
1449 break label_14;
1450 }
1451 }
1452 jj_consume_token(RCURLYBRACE);
1453 } else {
1454 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1455 case LPARENTHESIS:
1456 case SCOPE:
1457 case AMPERSAND:
1458 case PLUS:
1459 case MINUS:
1460 case STAR:
1461 case PLUSPLUS:
1462 case MINUSMINUS:
1463 case TILDE:
1464 case NOT:
1465 case BOOL:
1466 case CHAR:
1467 case DELETE:
1468 case DOUBLE:
1469 case FLOAT:
1470 case INT:
1471 case LONG:
1472 case NEW:
1473 case SHORT:
1474 case SIGNED:
1475 case SIZEOF:
1476 case TEMPLATE:
1477 case THIS:
1478 case TYPEID:
1479 case UNSIGNED:
1480 case VOID:
1481 case WCHAR_T:
1482 case OPERATOR:
1483 case TRUETOK:
1484 case FALSETOK:
1485 case THROW:
1486 case OCTALINT:
1487 case OCTALLONG:
1488 case UNSIGNED_OCTALINT:
1489 case UNSIGNED_OCTALLONG:
1490 case DECIMALINT:
1491 case DECIMALLONG:
1492 case UNSIGNED_DECIMALINT:
1493 case UNSIGNED_DECIMALLONG:
1494 case HEXADECIMALINT:
1495 case HEXADECIMALLONG:
1496 case UNSIGNED_HEXADECIMALINT:
1497 case UNSIGNED_HEXADECIMALLONG:
1498 case FLOATONE:
1499 case FLOATTWO:
1500 case CHARACTER:
1501 case STRING:
1502 case ID:
1503 assignment_expression();
1504 break;
1505 default:
1506 jj_la1[41] = jj_gen;
1507 jj_consume_token(-1);
1508 throw new ParseException();
1509 }
1510 }
1511 }
1512
1513 final public void class_specifier() throws ParseException {
1514 String name;
1515 if (jj_2_28(2147483647)) {
1516 AstClassDefinition jjtn001 = new AstClassDefinition(JJTCLASSDEFINITION);
1517 boolean jjtc001 = true;
1518 jjtree.openNodeScope(jjtn001);
1519 jjtreeOpenNodeScope(jjtn001);
1520 try {
1521 class_key();
1522 jj_consume_token(LCURLYBRACE);
1523 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1524 case LPARENTHESIS:
1525 case SCOPE:
1526 case SEMICOLON:
1527 case AMPERSAND:
1528 case STAR:
1529 case TILDE:
1530 case AUTO:
1531 case BOOL:
1532 case CHAR:
1533 case CONST:
1534 case DOUBLE:
1535 case ENUM:
1536 case EXPLICIT:
1537 case EXTERN:
1538 case FLOAT:
1539 case FRIEND:
1540 case INLINE:
1541 case INT:
1542 case LONG:
1543 case MUTABLE:
1544 case PRIVATE:
1545 case PROTECTED:
1546 case PUBLIC:
1547 case REGISTER:
1548 case SHORT:
1549 case SIGNED:
1550 case STATIC:
1551 case STRUCT:
1552 case CLASS:
1553 case TEMPLATE:
1554 case TYPEDEF:
1555 case TYPENAME:
1556 case UNION:
1557 case UNSIGNED:
1558 case USING:
1559 case VIRTUAL:
1560 case VOID:
1561 case VOLATILE:
1562 case WCHAR_T:
1563 case OPERATOR:
1564 case ID:
1565 member_specification();
1566 break;
1567 default:
1568 jj_la1[42] = jj_gen;
1569 ;
1570 }
1571 jj_consume_token(RCURLYBRACE);
1572 } catch (Throwable jjte001) {
1573 if (jjtc001) {
1574 jjtree.clearNodeScope(jjtn001);
1575 jjtc001 = false;
1576 } else {
1577 jjtree.popNode();
1578 }
1579 if (jjte001 instanceof RuntimeException) {
1580 {if (true) throw (RuntimeException)jjte001;}
1581 }
1582 if (jjte001 instanceof ParseException) {
1583 {if (true) throw (ParseException)jjte001;}
1584 }
1585 {if (true) throw (Error)jjte001;}
1586 } finally {
1587 if (jjtc001) {
1588 jjtree.closeNodeScope(jjtn001, true);
1589 jjtreeCloseNodeScope(jjtn001);
1590 }
1591 }
1592 } else if (jj_2_29(2147483647)) {
1593 AstClassDefinition jjtn002 = new AstClassDefinition(JJTCLASSDEFINITION);
1594 boolean jjtc002 = true;
1595 jjtree.openNodeScope(jjtn002);
1596 jjtreeOpenNodeScope(jjtn002);
1597 try {
1598 name = class_head();
1599 jj_consume_token(LCURLYBRACE);
1600 openScope( name );
1601 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1602 case LPARENTHESIS:
1603 case SCOPE:
1604 case SEMICOLON:
1605 case AMPERSAND:
1606 case STAR:
1607 case TILDE:
1608 case AUTO:
1609 case BOOL:
1610 case CHAR:
1611 case CONST:
1612 case DOUBLE:
1613 case ENUM:
1614 case EXPLICIT:
1615 case EXTERN:
1616 case FLOAT:
1617 case FRIEND:
1618 case INLINE:
1619 case INT:
1620 case LONG:
1621 case MUTABLE:
1622 case PRIVATE:
1623 case PROTECTED:
1624 case PUBLIC:
1625 case REGISTER:
1626 case SHORT:
1627 case SIGNED:
1628 case STATIC:
1629 case STRUCT:
1630 case CLASS:
1631 case TEMPLATE:
1632 case TYPEDEF:
1633 case TYPENAME:
1634 case UNION:
1635 case UNSIGNED:
1636 case USING:
1637 case VIRTUAL:
1638 case VOID:
1639 case VOLATILE:
1640 case WCHAR_T:
1641 case OPERATOR:
1642 case ID:
1643 member_specification();
1644 break;
1645 default:
1646 jj_la1[43] = jj_gen;
1647 ;
1648 }
1649 jj_consume_token(RCURLYBRACE);
1650 jjtree.closeNodeScope(jjtn002, true);
1651 jjtc002 = false;
1652 jjtreeCloseNodeScope(jjtn002);
1653 closeScope();
1654 } catch (Throwable jjte002) {
1655 if (jjtc002) {
1656 jjtree.clearNodeScope(jjtn002);
1657 jjtc002 = false;
1658 } else {
1659 jjtree.popNode();
1660 }
1661 if (jjte002 instanceof RuntimeException) {
1662 {if (true) throw (RuntimeException)jjte002;}
1663 }
1664 if (jjte002 instanceof ParseException) {
1665 {if (true) throw (ParseException)jjte002;}
1666 }
1667 {if (true) throw (Error)jjte002;}
1668 } finally {
1669 if (jjtc002) {
1670 jjtree.closeNodeScope(jjtn002, true);
1671 jjtreeCloseNodeScope(jjtn002);
1672 }
1673 }
1674 } else {
1675 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1676 case STRUCT:
1677 case CLASS:
1678 case UNION:
1679 AstClassDeclaration jjtn003 = new AstClassDeclaration(JJTCLASSDECLARATION);
1680 boolean jjtc003 = true;
1681 jjtree.openNodeScope(jjtn003);
1682 jjtreeOpenNodeScope(jjtn003);
1683 try {
1684 class_head();
1685 } catch (Throwable jjte003) {
1686 if (jjtc003) {
1687 jjtree.clearNodeScope(jjtn003);
1688 jjtc003 = false;
1689 } else {
1690 jjtree.popNode();
1691 }
1692 if (jjte003 instanceof RuntimeException) {
1693 {if (true) throw (RuntimeException)jjte003;}
1694 }
1695 if (jjte003 instanceof ParseException) {
1696 {if (true) throw (ParseException)jjte003;}
1697 }
1698 {if (true) throw (Error)jjte003;}
1699 } finally {
1700 if (jjtc003) {
1701 jjtree.closeNodeScope(jjtn003, true);
1702 jjtreeCloseNodeScope(jjtn003);
1703 }
1704 }
1705 break;
1706 default:
1707 jj_la1[44] = jj_gen;
1708 jj_consume_token(-1);
1709 throw new ParseException();
1710 }
1711 }
1712 }
1713
1714 final public void class_key() throws ParseException {
1715 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1716 case CLASS:
1717 jj_consume_token(CLASS);
1718 break;
1719 case STRUCT:
1720 jj_consume_token(STRUCT);
1721 break;
1722 case UNION:
1723 jj_consume_token(UNION);
1724 break;
1725 default:
1726 jj_la1[45] = jj_gen;
1727 jj_consume_token(-1);
1728 throw new ParseException();
1729 }
1730 }
1731
1732 final public String class_head() throws ParseException {
1733 Token t;
1734 String name = "";
1735 class_key();
1736 if (jj_2_30(2147483647)) {
1737 name = scope_override();
1738 } else {
1739 ;
1740 }
1741 t = jj_consume_token(ID);
1742 if (jj_2_31(2147483647)) {
1743 template_argument_list();
1744 } else {
1745 ;
1746 }
1747 if (jj_2_32(2147483647)) {
1748 base_clause();
1749 } else {
1750 ;
1751 }
1752 {if (true) return name + t.image;}
1753 throw new Error("Missing return statement in function");
1754 }
1755
1756 final public void base_clause() throws ParseException {
1757 jj_consume_token(COLON);
1758 base_specifier();
1759 label_15:
1760 while (true) {
1761 if (jj_2_33(2147483647)) {
1762 ;
1763 } else {
1764 break label_15;
1765 }
1766 jj_consume_token(COMMA);
1767 base_specifier();
1768 }
1769 }
1770
1771 final public void base_specifier() throws ParseException {
1772 Token t;
1773 String name = "";
1774 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1775 case PRIVATE:
1776 case PROTECTED:
1777 case PUBLIC:
1778 case VIRTUAL:
1779 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1780 case VIRTUAL:
1781 jj_consume_token(VIRTUAL);
1782 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1783 case PRIVATE:
1784 case PROTECTED:
1785 case PUBLIC:
1786 access_specifier();
1787 break;
1788 default:
1789 jj_la1[46] = jj_gen;
1790 ;
1791 }
1792 break;
1793 case PRIVATE:
1794 case PROTECTED:
1795 case PUBLIC:
1796 access_specifier();
1797 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1798 case VIRTUAL:
1799 jj_consume_token(VIRTUAL);
1800 break;
1801 default:
1802 jj_la1[47] = jj_gen;
1803 ;
1804 }
1805 break;
1806 default:
1807 jj_la1[48] = jj_gen;
1808 jj_consume_token(-1);
1809 throw new ParseException();
1810 }
1811 break;
1812 default:
1813 jj_la1[49] = jj_gen;
1814 ;
1815 }
1816 if (jj_2_34(2147483647)) {
1817 name = scope_override();
1818 } else {
1819 ;
1820 }
1821 t = jj_consume_token(ID);
1822 if (jj_2_35(2147483647)) {
1823 template_argument_list();
1824 } else {
1825 ;
1826 }
1827 extendScope( name + t.image );
1828 }
1829
1830 final public void member_specification() throws ParseException {
1831 label_16:
1832 while (true) {
1833 if (jj_2_36(2147483647)) {
1834 access_specifier();
1835 jj_consume_token(COLON);
1836 } else {
1837 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1838 case LPARENTHESIS:
1839 case SCOPE:
1840 case SEMICOLON:
1841 case AMPERSAND:
1842 case STAR:
1843 case TILDE:
1844 case AUTO:
1845 case BOOL:
1846 case CHAR:
1847 case CONST:
1848 case DOUBLE:
1849 case ENUM:
1850 case EXPLICIT:
1851 case EXTERN:
1852 case FLOAT:
1853 case FRIEND:
1854 case INLINE:
1855 case INT:
1856 case LONG:
1857 case MUTABLE:
1858 case REGISTER:
1859 case SHORT:
1860 case SIGNED:
1861 case STATIC:
1862 case STRUCT:
1863 case CLASS:
1864 case TEMPLATE:
1865 case TYPEDEF:
1866 case TYPENAME:
1867 case UNION:
1868 case UNSIGNED:
1869 case USING:
1870 case VIRTUAL:
1871 case VOID:
1872 case VOLATILE:
1873 case WCHAR_T:
1874 case OPERATOR:
1875 case ID:
1876 member_declaration();
1877 break;
1878 default:
1879 jj_la1[50] = jj_gen;
1880 jj_consume_token(-1);
1881 throw new ParseException();
1882 }
1883 }
1884 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1885 case LPARENTHESIS:
1886 case SCOPE:
1887 case SEMICOLON:
1888 case AMPERSAND:
1889 case STAR:
1890 case TILDE:
1891 case AUTO:
1892 case BOOL:
1893 case CHAR:
1894 case CONST:
1895 case DOUBLE:
1896 case ENUM:
1897 case EXPLICIT:
1898 case EXTERN:
1899 case FLOAT:
1900 case FRIEND:
1901 case INLINE:
1902 case INT:
1903 case LONG:
1904 case MUTABLE:
1905 case PRIVATE:
1906 case PROTECTED:
1907 case PUBLIC:
1908 case REGISTER:
1909 case SHORT:
1910 case SIGNED:
1911 case STATIC:
1912 case STRUCT:
1913 case CLASS:
1914 case TEMPLATE:
1915 case TYPEDEF:
1916 case TYPENAME:
1917 case UNION:
1918 case UNSIGNED:
1919 case USING:
1920 case VIRTUAL:
1921 case VOID:
1922 case VOLATILE:
1923 case WCHAR_T:
1924 case OPERATOR:
1925 case ID:
1926 ;
1927 break;
1928 default:
1929 jj_la1[51] = jj_gen;
1930 break label_16;
1931 }
1932 }
1933 }
1934
1935 final public void access_specifier() throws ParseException {
1936 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1937 case PUBLIC:
1938 jj_consume_token(PUBLIC);
1939 break;
1940 case PROTECTED:
1941 jj_consume_token(PROTECTED);
1942 break;
1943 case PRIVATE:
1944 jj_consume_token(PRIVATE);
1945 break;
1946 default:
1947 jj_la1[52] = jj_gen;
1948 jj_consume_token(-1);
1949 throw new ParseException();
1950 }
1951 }
1952
1953 final public void member_declaration() throws ParseException {
1954 if (jj_2_42(2147483647)) {
1955 conversion_function_decl_or_def();
1956 } else if (jj_2_43(2147483647)) {
1957 if (jj_2_37(2147483647)) {
1958 template_head();
1959 } else {
1960 ;
1961 }
1962 dtor_definition();
1963 } else if (jj_2_44(2147483647)) {
1964 AstDestructorDeclaration jjtn001 = new AstDestructorDeclaration(JJTDESTRUCTORDECLARATION);
1965 boolean jjtc001 = true;
1966 jjtree.openNodeScope(jjtn001);
1967 jjtreeOpenNodeScope(jjtn001);
1968 try {
1969 dtor_ctor_decl_spec();
1970 simple_dtor_declarator();
1971 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1972 case ASSIGNEQUAL:
1973 pure_specifier();
1974 break;
1975 default:
1976 jj_la1[53] = jj_gen;
1977 ;
1978 }
1979 jj_consume_token(SEMICOLON);
1980 } catch (Throwable jjte001) {
1981 if (jjtc001) {
1982 jjtree.clearNodeScope(jjtn001);
1983 jjtc001 = false;
1984 } else {
1985 jjtree.popNode();
1986 }
1987 if (jjte001 instanceof RuntimeException) {
1988 {if (true) throw (RuntimeException)jjte001;}
1989 }
1990 if (jjte001 instanceof ParseException) {
1991 {if (true) throw (ParseException)jjte001;}
1992 }
1993 {if (true) throw (Error)jjte001;}
1994 } finally {
1995 if (jjtc001) {
1996 jjtree.closeNodeScope(jjtn001, true);
1997 jjtreeCloseNodeScope(jjtn001);
1998 }
1999 }
2000 } else if (jj_2_45(2147483647)) {
2001 if (jj_2_38(2147483647)) {
2002 template_head();
2003 } else {
2004 ;
2005 }
2006 AstConstructorDeclaration jjtn002 = new AstConstructorDeclaration(JJTCONSTRUCTORDECLARATION);
2007 boolean jjtc002 = true;
2008 jjtree.openNodeScope(jjtn002);
2009 jjtreeOpenNodeScope(jjtn002);
2010 try {
2011 dtor_ctor_decl_spec();
2012 ctor_declarator();
2013 jj_consume_token(SEMICOLON);
2014 } catch (Throwable jjte002) {
2015 if (jjtc002) {
2016 jjtree.clearNodeScope(jjtn002);
2017 jjtc002 = false;
2018 } else {
2019 jjtree.popNode();
2020 }
2021 if (jjte002 instanceof RuntimeException) {
2022 {if (true) throw (RuntimeException)jjte002;}
2023 }
2024 if (jjte002 instanceof ParseException) {
2025 {if (true) throw (ParseException)jjte002;}
2026 }
2027 {if (true) throw (Error)jjte002;}
2028 } finally {
2029 if (jjtc002) {
2030 jjtree.closeNodeScope(jjtn002, true);
2031 jjtreeCloseNodeScope(jjtn002);
2032 }
2033 }
2034 } else if (jj_2_46(2147483647)) {
2035 if (jj_2_39(2147483647)) {
2036 template_head();
2037 } else {
2038 ;
2039 }
2040 ctor_definition();
2041 } else if (jj_2_47(2147483647)) {
2042 if (jj_2_40(2147483647)) {
2043 template_head();
2044 } else {
2045 ;
2046 }
2047 function_decl_or_def();
2048 } else if (jj_2_48(2147483647)) {
2049 if (jj_2_41(2147483647)) {
2050 template_head();
2051 } else {
2052 ;
2053 }
2054 AstMemberDeclaration jjtn003 = new AstMemberDeclaration(JJTMEMBERDECLARATION);
2055 boolean jjtc003 = true;
2056 jjtree.openNodeScope(jjtn003);
2057 jjtreeOpenNodeScope(jjtn003);
2058 try {
2059 declaration_specifiers();
2060 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2061 case LPARENTHESIS:
2062 case SCOPE:
2063 case AMPERSAND:
2064 case STAR:
2065 case TEMPLATE:
2066 case OPERATOR:
2067 case ID:
2068 member_declarator_list();
2069 break;
2070 default:
2071 jj_la1[54] = jj_gen;
2072 ;
2073 }
2074 jj_consume_token(SEMICOLON);
2075 } catch (Throwable jjte003) {
2076 if (jjtc003) {
2077 jjtree.clearNodeScope(jjtn003);
2078 jjtc003 = false;
2079 } else {
2080 jjtree.popNode();
2081 }
2082 if (jjte003 instanceof RuntimeException) {
2083 {if (true) throw (RuntimeException)jjte003;}
2084 }
2085 if (jjte003 instanceof ParseException) {
2086 {if (true) throw (ParseException)jjte003;}
2087 }
2088 {if (true) throw (Error)jjte003;}
2089 } finally {
2090 if (jjtc003) {
2091 jjtree.closeNodeScope(jjtn003, true);
2092 jjtreeCloseNodeScope(jjtn003);
2093 }
2094 }
2095 } else if (jj_2_49(2147483647)) {
2096 using_declaration();
2097 } else {
2098 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2099 case SEMICOLON:
2100 jj_consume_token(SEMICOLON);
2101 break;
2102 default:
2103 jj_la1[55] = jj_gen;
2104 jj_consume_token(-1);
2105 throw new ParseException();
2106 }
2107 }
2108 }
2109
2110 final public void member_declarator_list() throws ParseException {
2111 member_declarator();
2112 label_17:
2113 while (true) {
2114 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2115 case COMMA:
2116 ;
2117 break;
2118 default:
2119 jj_la1[56] = jj_gen;
2120 break label_17;
2121 }
2122 jj_consume_token(COMMA);
2123 member_declarator();
2124 }
2125 }
2126
2127 final public void member_declarator() throws ParseException {
2128 declarator();
2129 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2130 case COLON:
2131 case ASSIGNEQUAL:
2132 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2133 case ASSIGNEQUAL:
2134 jj_consume_token(ASSIGNEQUAL);
2135 break;
2136 case COLON:
2137 jj_consume_token(COLON);
2138 break;
2139 default:
2140 jj_la1[57] = jj_gen;
2141 jj_consume_token(-1);
2142 throw new ParseException();
2143 }
2144 assignment_expression();
2145 break;
2146 default:
2147 jj_la1[58] = jj_gen;
2148 ;
2149 }
2150 }
2151
2152 final public void pure_specifier() throws ParseException {
2153 jj_consume_token(ASSIGNEQUAL);
2154 jj_consume_token(OCTALINT);
2155 }
2156
2157 final public void enum_specifier() throws ParseException {
2158
2159 AstEnumSpecifier jjtn000 = new AstEnumSpecifier(JJTENUMSPECIFIER);
2160 boolean jjtc000 = true;
2161 jjtree.openNodeScope(jjtn000);
2162 jjtreeOpenNodeScope(jjtn000);
2163 try {
2164 jj_consume_token(ENUM);
2165 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2166 case LCURLYBRACE:
2167 jj_consume_token(LCURLYBRACE);
2168 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2169 case ID:
2170 enumerator_list();
2171 break;
2172 default:
2173 jj_la1[59] = jj_gen;
2174 ;
2175 }
2176 jj_consume_token(RCURLYBRACE);
2177 break;
2178 case ID:
2179 jj_consume_token(ID);
2180 if (jj_2_50(2147483647)) {
2181 jj_consume_token(LCURLYBRACE);
2182 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2183 case ID:
2184 enumerator_list();
2185 break;
2186 default:
2187 jj_la1[60] = jj_gen;
2188 ;
2189 }
2190 jj_consume_token(RCURLYBRACE);
2191 } else {
2192 ;
2193 }
2194 break;
2195 default:
2196 jj_la1[61] = jj_gen;
2197 jj_consume_token(-1);
2198 throw new ParseException();
2199 }
2200 } catch (Throwable jjte000) {
2201 if (jjtc000) {
2202 jjtree.clearNodeScope(jjtn000);
2203 jjtc000 = false;
2204 } else {
2205 jjtree.popNode();
2206 }
2207 if (jjte000 instanceof RuntimeException) {
2208 {if (true) throw (RuntimeException)jjte000;}
2209 }
2210 if (jjte000 instanceof ParseException) {
2211 {if (true) throw (ParseException)jjte000;}
2212 }
2213 {if (true) throw (Error)jjte000;}
2214 } finally {
2215 if (jjtc000) {
2216 jjtree.closeNodeScope(jjtn000, true);
2217 jjtreeCloseNodeScope(jjtn000);
2218 }
2219 }
2220 }
2221
2222 final public void enumerator_list() throws ParseException {
2223 label_18:
2224 while (true) {
2225 enumerator();
2226 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2227 case COMMA:
2228 jj_consume_token(COMMA);
2229 break;
2230 default:
2231 jj_la1[62] = jj_gen;
2232 ;
2233 }
2234 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2235 case ID:
2236 ;
2237 break;
2238 default:
2239 jj_la1[63] = jj_gen;
2240 break label_18;
2241 }
2242 }
2243 }
2244
2245 final public void enumerator() throws ParseException {
2246 jj_consume_token(ID);
2247 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2248 case ASSIGNEQUAL:
2249 jj_consume_token(ASSIGNEQUAL);
2250 assignment_expression();
2251 break;
2252 default:
2253 jj_la1[64] = jj_gen;
2254 ;
2255 }
2256 }
2257
2258 final public void ptr_operator() throws ParseException {
2259 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2260 case AMPERSAND:
2261 jj_consume_token(AMPERSAND);
2262 break;
2263 case STAR:
2264 jj_consume_token(STAR);
2265 cv_qualifier_seq();
2266 break;
2267 case SCOPE:
2268 case TEMPLATE:
2269 case ID:
2270 scope_override();
2271 jj_consume_token(STAR);
2272 cv_qualifier_seq();
2273 break;
2274 default:
2275 jj_la1[65] = jj_gen;
2276 jj_consume_token(-1);
2277 throw new ParseException();
2278 }
2279 }
2280
2281 final public void cv_qualifier_seq() throws ParseException {
2282 if (jj_2_53(2)) {
2283 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2284 case CONST:
2285 jj_consume_token(CONST);
2286 if (jj_2_51(2147483647)) {
2287 jj_consume_token(VOLATILE);
2288 } else {
2289 ;
2290 }
2291 break;
2292 case VOLATILE:
2293 jj_consume_token(VOLATILE);
2294 if (jj_2_52(2147483647)) {
2295 jj_consume_token(CONST);
2296 } else {
2297 ;
2298 }
2299 break;
2300 default:
2301 jj_la1[66] = jj_gen;
2302 jj_consume_token(-1);
2303 throw new ParseException();
2304 }
2305 } else {
2306 ;
2307 }
2308 }
2309
2310 final public void function_declarator_lookahead() throws ParseException {
2311 if (jj_2_54(2147483647)) {
2312 ptr_operator_seq();
2313 } else {
2314 ;
2315 }
2316 qualified_id();
2317 jj_consume_token(LPARENTHESIS);
2318 }
2319
2320 final public void function_declarator() throws ParseException {
2321 if (jj_2_55(2147483647)) {
2322 ptr_operator_seq();
2323 } else {
2324 ;
2325 }
2326 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2327 case LPARENTHESIS:
2328 jj_consume_token(LPARENTHESIS);
2329 jj_consume_token(STAR);
2330 function_direct_declarator();
2331 AstFunctionPointerPostfix jjtn001 = new AstFunctionPointerPostfix(JJTFUNCTIONPOINTERPOSTFIX);
2332 boolean jjtc001 = true;
2333 jjtree.openNodeScope(jjtn001);
2334 jjtreeOpenNodeScope(jjtn001);
2335 try {
2336 jj_consume_token(RPARENTHESIS);
2337 function_parameters();
2338 } catch (Throwable jjte001) {
2339 if (jjtc001) {
2340 jjtree.clearNodeScope(jjtn001);
2341 jjtc001 = false;
2342 } else {
2343 jjtree.popNode();
2344 }
2345 if (jjte001 instanceof RuntimeException) {
2346 {if (true) throw (RuntimeException)jjte001;}
2347 }
2348 if (jjte001 instanceof ParseException) {
2349 {if (true) throw (ParseException)jjte001;}
2350 }
2351 {if (true) throw (Error)jjte001;}
2352 } finally {
2353 if (jjtc001) {
2354 jjtree.closeNodeScope(jjtn001, true);
2355 jjtreeCloseNodeScope(jjtn001);
2356 }
2357 }
2358 break;
2359 case SCOPE:
2360 case TEMPLATE:
2361 case OPERATOR:
2362 case ID:
2363 function_direct_declarator();
2364 break;
2365 default:
2366 jj_la1[67] = jj_gen;
2367 jj_consume_token(-1);
2368 throw new ParseException();
2369 }
2370 cv_qualifier_seq();
2371 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2372 case THROW:
2373 exception_spec();
2374 break;
2375 default:
2376 jj_la1[68] = jj_gen;
2377 ;
2378 }
2379 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2380 case ASSIGNEQUAL:
2381 pure_specifier();
2382 break;
2383 default:
2384 jj_la1[69] = jj_gen;
2385 ;
2386 }
2387 }
2388
2389 final public void function_direct_declarator() throws ParseException {
2390 AstFunctionName jjtn001 = new AstFunctionName(JJTFUNCTIONNAME);
2391 boolean jjtc001 = true;
2392 jjtree.openNodeScope(jjtn001);
2393 jjtreeOpenNodeScope(jjtn001);
2394 try {
2395 qualified_id();
2396 } catch (Throwable jjte001) {
2397 if (jjtc001) {
2398 jjtree.clearNodeScope(jjtn001);
2399 jjtc001 = false;
2400 } else {
2401 jjtree.popNode();
2402 }
2403 if (jjte001 instanceof RuntimeException) {
2404 {if (true) throw (RuntimeException)jjte001;}
2405 }
2406 if (jjte001 instanceof ParseException) {
2407 {if (true) throw (ParseException)jjte001;}
2408 }
2409 {if (true) throw (Error)jjte001;}
2410 } finally {
2411 if (jjtc001) {
2412 jjtree.closeNodeScope(jjtn001, true);
2413 jjtreeCloseNodeScope(jjtn001);
2414 }
2415 }
2416 function_parameters();
2417 }
2418
2419 final public void dtor_ctor_decl_spec() throws ParseException {
2420 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2421 case EXPLICIT:
2422 case INLINE:
2423 case VIRTUAL:
2424 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2425 case EXPLICIT:
2426 case VIRTUAL:
2427 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2428 case VIRTUAL:
2429 jj_consume_token(VIRTUAL);
2430 break;
2431 case EXPLICIT:
2432 jj_consume_token(EXPLICIT);
2433 break;
2434 default:
2435 jj_la1[70] = jj_gen;
2436 jj_consume_token(-1);
2437 throw new ParseException();
2438 }
2439 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2440 case INLINE:
2441 jj_consume_token(INLINE);
2442 break;
2443 default:
2444 jj_la1[71] = jj_gen;
2445 ;
2446 }
2447 break;
2448 case INLINE:
2449 jj_consume_token(INLINE);
2450 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2451 case EXPLICIT:
2452 case VIRTUAL:
2453 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2454 case VIRTUAL:
2455 jj_consume_token(VIRTUAL);
2456 break;
2457 case EXPLICIT:
2458 jj_consume_token(EXPLICIT);
2459 break;
2460 default:
2461 jj_la1[72] = jj_gen;
2462 jj_consume_token(-1);
2463 throw new ParseException();
2464 }
2465 break;
2466 default:
2467 jj_la1[73] = jj_gen;
2468 ;
2469 }
2470 break;
2471 default:
2472 jj_la1[74] = jj_gen;
2473 jj_consume_token(-1);
2474 throw new ParseException();
2475 }
2476 break;
2477 default:
2478 jj_la1[75] = jj_gen;
2479 ;
2480 }
2481 }
2482
2483 final public void dtor_definition() throws ParseException {
2484
2485 AstDestructorDefinition jjtn000 = new AstDestructorDefinition(JJTDESTRUCTORDEFINITION);
2486 boolean jjtc000 = true;
2487 jjtree.openNodeScope(jjtn000);
2488 jjtreeOpenNodeScope(jjtn000);
2489 try {
2490 dtor_ctor_decl_spec();
2491 dtor_declarator();
2492 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2493 case ASSIGNEQUAL:
2494 pure_specifier();
2495 break;
2496 default:
2497 jj_la1[76] = jj_gen;
2498 ;
2499 }
2500 AstFunctionBody jjtn001 = new AstFunctionBody(JJTFUNCTIONBODY);
2501 boolean jjtc001 = true;
2502 jjtree.openNodeScope(jjtn001);
2503 jjtreeOpenNodeScope(jjtn001);
2504 try {
2505 compound_statement();
2506 } catch (Throwable jjte001) {
2507 if (jjtc001) {
2508 jjtree.clearNodeScope(jjtn001);
2509 jjtc001 = false;
2510 } else {
2511 jjtree.popNode();
2512 }
2513 if (jjte001 instanceof RuntimeException) {
2514 {if (true) throw (RuntimeException)jjte001;}
2515 }
2516 if (jjte001 instanceof ParseException) {
2517 {if (true) throw (ParseException)jjte001;}
2518 }
2519 {if (true) throw (Error)jjte001;}
2520 } finally {
2521 if (jjtc001) {
2522 jjtree.closeNodeScope(jjtn001, true);
2523 jjtreeCloseNodeScope(jjtn001);
2524 }
2525 }
2526 } catch (Throwable jjte000) {
2527 if (jjtc000) {
2528 jjtree.clearNodeScope(jjtn000);
2529 jjtc000 = false;
2530 } else {
2531 jjtree.popNode();
2532 }
2533 if (jjte000 instanceof RuntimeException) {
2534 {if (true) throw (RuntimeException)jjte000;}
2535 }
2536 if (jjte000 instanceof ParseException) {
2537 {if (true) throw (ParseException)jjte000;}
2538 }
2539 {if (true) throw (Error)jjte000;}
2540 } finally {
2541 if (jjtc000) {
2542 jjtree.closeNodeScope(jjtn000, true);
2543 jjtreeCloseNodeScope(jjtn000);
2544 }
2545 }
2546 }
2547
2548 final public void ctor_definition() throws ParseException {
2549
2550 AstConstructorDefinition jjtn000 = new AstConstructorDefinition(JJTCONSTRUCTORDEFINITION);
2551 boolean jjtc000 = true;
2552 jjtree.openNodeScope(jjtn000);
2553 jjtreeOpenNodeScope(jjtn000);
2554 try {
2555 dtor_ctor_decl_spec();
2556 ctor_declarator();
2557 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2558 case COLON:
2559 ctor_initializer();
2560 break;
2561 default:
2562 jj_la1[77] = jj_gen;
2563 ;
2564 }
2565 AstFunctionBody jjtn001 = new AstFunctionBody(JJTFUNCTIONBODY);
2566 boolean jjtc001 = true;
2567 jjtree.openNodeScope(jjtn001);
2568 jjtreeOpenNodeScope(jjtn001);
2569 try {
2570 compound_statement();
2571 } catch (Throwable jjte001) {
2572 if (jjtc001) {
2573 jjtree.clearNodeScope(jjtn001);
2574 jjtc001 = false;
2575 } else {
2576 jjtree.popNode();
2577 }
2578 if (jjte001 instanceof RuntimeException) {
2579 {if (true) throw (RuntimeException)jjte001;}
2580 }
2581 if (jjte001 instanceof ParseException) {
2582 {if (true) throw (ParseException)jjte001;}
2583 }
2584 {if (true) throw (Error)jjte001;}
2585 } finally {
2586 if (jjtc001) {
2587 jjtree.closeNodeScope(jjtn001, true);
2588 jjtreeCloseNodeScope(jjtn001);
2589 }
2590 }
2591 } catch (Throwable jjte000) {
2592 if (jjtc000) {
2593 jjtree.clearNodeScope(jjtn000);
2594 jjtc000 = false;
2595 } else {
2596 jjtree.popNode();
2597 }
2598 if (jjte000 instanceof RuntimeException) {
2599 {if (true) throw (RuntimeException)jjte000;}
2600 }
2601 if (jjte000 instanceof ParseException) {
2602 {if (true) throw (ParseException)jjte000;}
2603 }
2604 {if (true) throw (Error)jjte000;}
2605 } finally {
2606 if (jjtc000) {
2607 jjtree.closeNodeScope(jjtn000, true);
2608 jjtreeCloseNodeScope(jjtn000);
2609 }
2610 }
2611 }
2612
2613 final public void ctor_declarator() throws ParseException {
2614 AstFunctionName jjtn001 = new AstFunctionName(JJTFUNCTIONNAME);
2615 boolean jjtc001 = true;
2616 jjtree.openNodeScope(jjtn001);
2617 jjtreeOpenNodeScope(jjtn001);
2618 try {
2619 qualified_type();
2620 } catch (Throwable jjte001) {
2621 if (jjtc001) {
2622 jjtree.clearNodeScope(jjtn001);
2623 jjtc001 = false;
2624 } else {
2625 jjtree.popNode();
2626 }
2627 if (jjte001 instanceof RuntimeException) {
2628 {if (true) throw (RuntimeException)jjte001;}
2629 }
2630 if (jjte001 instanceof ParseException) {
2631 {if (true) throw (ParseException)jjte001;}
2632 }
2633 {if (true) throw (Error)jjte001;}
2634 } finally {
2635 if (jjtc001) {
2636 jjtree.closeNodeScope(jjtn001, true);
2637 jjtreeCloseNodeScope(jjtn001);
2638 }
2639 }
2640 function_parameters();
2641 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2642 case THROW:
2643 exception_spec();
2644 break;
2645 default:
2646 jj_la1[78] = jj_gen;
2647 ;
2648 }
2649 }
2650
2651 final public void ctor_initializer() throws ParseException {
2652 jj_consume_token(COLON);
2653 mem_initializer();
2654 label_19:
2655 while (true) {
2656 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2657 case COMMA:
2658 ;
2659 break;
2660 default:
2661 jj_la1[79] = jj_gen;
2662 break label_19;
2663 }
2664 jj_consume_token(COMMA);
2665 mem_initializer();
2666 }
2667 }
2668
2669 final public void mem_initializer() throws ParseException {
2670
2671 AstConstructorInitializer jjtn000 = new AstConstructorInitializer(JJTCONSTRUCTORINITIALIZER);
2672 boolean jjtc000 = true;
2673 jjtree.openNodeScope(jjtn000);
2674 jjtreeOpenNodeScope(jjtn000);
2675 try {
2676 mem_initializer_id();
2677 jj_consume_token(LPARENTHESIS);
2678 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2679 case LPARENTHESIS:
2680 case SCOPE:
2681 case AMPERSAND:
2682 case PLUS:
2683 case MINUS:
2684 case STAR:
2685 case PLUSPLUS:
2686 case MINUSMINUS:
2687 case TILDE:
2688 case NOT:
2689 case BOOL:
2690 case CHAR:
2691 case DELETE:
2692 case DOUBLE:
2693 case FLOAT:
2694 case INT:
2695 case LONG:
2696 case NEW:
2697 case SHORT:
2698 case SIGNED:
2699 case SIZEOF:
2700 case TEMPLATE:
2701 case THIS:
2702 case TYPEID:
2703 case UNSIGNED:
2704 case VOID:
2705 case WCHAR_T:
2706 case OPERATOR:
2707 case TRUETOK:
2708 case FALSETOK:
2709 case THROW:
2710 case OCTALINT:
2711 case OCTALLONG:
2712 case UNSIGNED_OCTALINT:
2713 case UNSIGNED_OCTALLONG:
2714 case DECIMALINT:
2715 case DECIMALLONG:
2716 case UNSIGNED_DECIMALINT:
2717 case UNSIGNED_DECIMALLONG:
2718 case HEXADECIMALINT:
2719 case HEXADECIMALLONG:
2720 case UNSIGNED_HEXADECIMALINT:
2721 case UNSIGNED_HEXADECIMALLONG:
2722 case FLOATONE:
2723 case FLOATTWO:
2724 case CHARACTER:
2725 case STRING:
2726 case ID:
2727 expression_list();
2728 break;
2729 default:
2730 jj_la1[80] = jj_gen;
2731 ;
2732 }
2733 jj_consume_token(RPARENTHESIS);
2734 } catch (Throwable jjte000) {
2735 if (jjtc000) {
2736 jjtree.clearNodeScope(jjtn000);
2737 jjtc000 = false;
2738 } else {
2739 jjtree.popNode();
2740 }
2741 if (jjte000 instanceof RuntimeException) {
2742 {if (true) throw (RuntimeException)jjte000;}
2743 }
2744 if (jjte000 instanceof ParseException) {
2745 {if (true) throw (ParseException)jjte000;}
2746 }
2747 {if (true) throw (Error)jjte000;}
2748 } finally {
2749 if (jjtc000) {
2750 jjtree.closeNodeScope(jjtn000, true);
2751 jjtreeCloseNodeScope(jjtn000);
2752 }
2753 }
2754 }
2755
2756 final public void mem_initializer_id() throws ParseException {
2757 if (jj_2_56(2147483647)) {
2758 scope_override();
2759 } else {
2760 ;
2761 }
2762 class_name();
2763 }
2764
2765 final public void class_name() throws ParseException {
2766 if (jj_2_57(2147483647)) {
2767 template_id();
2768 } else {
2769 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2770 case ID:
2771 jj_consume_token(ID);
2772 break;
2773 default:
2774 jj_la1[81] = jj_gen;
2775 jj_consume_token(-1);
2776 throw new ParseException();
2777 }
2778 }
2779 }
2780
2781 final public void dtor_declarator() throws ParseException {
2782 AstFunctionName jjtn001 = new AstFunctionName(JJTFUNCTIONNAME);
2783 boolean jjtc001 = true;
2784 jjtree.openNodeScope(jjtn001);
2785 jjtreeOpenNodeScope(jjtn001);
2786 try {
2787 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2788 case SCOPE:
2789 case TEMPLATE:
2790 case ID:
2791 scope_override();
2792 break;
2793 default:
2794 jj_la1[82] = jj_gen;
2795 ;
2796 }
2797 jj_consume_token(TILDE);
2798 jj_consume_token(ID);
2799 } catch (Throwable jjte001) {
2800 if (jjtc001) {
2801 jjtree.clearNodeScope(jjtn001);
2802 jjtc001 = false;
2803 } else {
2804 jjtree.popNode();
2805 }
2806 if (jjte001 instanceof RuntimeException) {
2807 {if (true) throw (RuntimeException)jjte001;}
2808 }
2809 if (jjte001 instanceof ParseException) {
2810 {if (true) throw (ParseException)jjte001;}
2811 }
2812 {if (true) throw (Error)jjte001;}
2813 } finally {
2814 if (jjtc001) {
2815 jjtree.closeNodeScope(jjtn001, true);
2816 jjtreeCloseNodeScope(jjtn001);
2817 }
2818 }
2819 AstFunctionParameters jjtn002 = new AstFunctionParameters(JJTFUNCTIONPARAMETERS);
2820 boolean jjtc002 = true;
2821 jjtree.openNodeScope(jjtn002);
2822 jjtreeOpenNodeScope(jjtn002);
2823 try {
2824 jj_consume_token(LPARENTHESIS);
2825 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2826 case VOID:
2827 jj_consume_token(VOID);
2828 break;
2829 default:
2830 jj_la1[83] = jj_gen;
2831 ;
2832 }
2833 jj_consume_token(RPARENTHESIS);
2834 } finally {
2835 if (jjtc002) {
2836 jjtree.closeNodeScope(jjtn002, true);
2837 jjtreeCloseNodeScope(jjtn002);
2838 }
2839 }
2840 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2841 case THROW:
2842 exception_spec();
2843 break;
2844 default:
2845 jj_la1[84] = jj_gen;
2846 ;
2847 }
2848 }
2849
2850 final public void simple_dtor_declarator() throws ParseException {
2851 AstFunctionName jjtn001 = new AstFunctionName(JJTFUNCTIONNAME);
2852 boolean jjtc001 = true;
2853 jjtree.openNodeScope(jjtn001);
2854 jjtreeOpenNodeScope(jjtn001);
2855 try {
2856 jj_consume_token(TILDE);
2857 jj_consume_token(ID);
2858 } finally {
2859 if (jjtc001) {
2860 jjtree.closeNodeScope(jjtn001, true);
2861 jjtreeCloseNodeScope(jjtn001);
2862 }
2863 }
2864 jj_consume_token(LPARENTHESIS);
2865 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2866 case VOID:
2867 jj_consume_token(VOID);
2868 break;
2869 default:
2870 jj_la1[85] = jj_gen;
2871 ;
2872 }
2873 jj_consume_token(RPARENTHESIS);
2874 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2875 case THROW:
2876 exception_spec();
2877 break;
2878 default:
2879 jj_la1[86] = jj_gen;
2880 ;
2881 }
2882 }
2883
2884 final public void parameter_declaration_list() throws ParseException {
2885 parameter_declaration();
2886 label_20:
2887 while (true) {
2888 if (jj_2_58(2)) {
2889 ;
2890 } else {
2891 break label_20;
2892 }
2893 jj_consume_token(COMMA);
2894 parameter_declaration();
2895 }
2896 }
2897
2898 final public void parameter_declaration() throws ParseException {
2899
2900 AstParameter jjtn000 = new AstParameter(JJTPARAMETER);
2901 boolean jjtc000 = true;
2902 jjtree.openNodeScope(jjtn000);
2903 jjtreeOpenNodeScope(jjtn000);
2904 try {
2905 AstParameterType jjtn001 = new AstParameterType(JJTPARAMETERTYPE);
2906 boolean jjtc001 = true;
2907 jjtree.openNodeScope(jjtn001);
2908 jjtreeOpenNodeScope(jjtn001);
2909 try {
2910 declaration_specifiers();
2911 } catch (Throwable jjte001) {
2912 if (jjtc001) {
2913 jjtree.clearNodeScope(jjtn001);
2914 jjtc001 = false;
2915 } else {
2916 jjtree.popNode();
2917 }
2918 if (jjte001 instanceof RuntimeException) {
2919 {if (true) throw (RuntimeException)jjte001;}
2920 }
2921 if (jjte001 instanceof ParseException) {
2922 {if (true) throw (ParseException)jjte001;}
2923 }
2924 {if (true) throw (Error)jjte001;}
2925 } finally {
2926 if (jjtc001) {
2927 jjtree.closeNodeScope(jjtn001, true);
2928 jjtreeCloseNodeScope(jjtn001);
2929 }
2930 }
2931 if (jj_2_59(2147483647)) {
2932 declarator();
2933 } else {
2934 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2935 case LSQUAREBRACKET:
2936 case LPARENTHESIS:
2937 case SCOPE:
2938 case AMPERSAND:
2939 case STAR:
2940 case TEMPLATE:
2941 case ID:
2942 AstParameterTypeQualifier jjtn002 = new AstParameterTypeQualifier(JJTPARAMETERTYPEQUALIFIER);
2943 boolean jjtc002 = true;
2944 jjtree.openNodeScope(jjtn002);
2945 jjtreeOpenNodeScope(jjtn002);
2946 try {
2947 abstract_declarator();
2948 } catch (Throwable jjte002) {
2949 if (jjtc002) {
2950 jjtree.clearNodeScope(jjtn002);
2951 jjtc002 = false;
2952 } else {
2953 jjtree.popNode();
2954 }
2955 if (jjte002 instanceof RuntimeException) {
2956 {if (true) throw (RuntimeException)jjte002;}
2957 }
2958 if (jjte002 instanceof ParseException) {
2959 {if (true) throw (ParseException)jjte002;}
2960 }
2961 {if (true) throw (Error)jjte002;}
2962 } finally {
2963 if (jjtc002) {
2964 jjtree.closeNodeScope(jjtn002, true);
2965 jjtreeCloseNodeScope(jjtn002);
2966 }
2967 }
2968 break;
2969 default:
2970 jj_la1[87] = jj_gen;
2971 ;
2972 }
2973 }
2974 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2975 case ASSIGNEQUAL:
2976 jj_consume_token(ASSIGNEQUAL);
2977 assignment_expression();
2978 break;
2979 default:
2980 jj_la1[88] = jj_gen;
2981 ;
2982 }
2983 } catch (Throwable jjte000) {
2984 if (jjtc000) {
2985 jjtree.clearNodeScope(jjtn000);
2986 jjtc000 = false;
2987 } else {
2988 jjtree.popNode();
2989 }
2990 if (jjte000 instanceof RuntimeException) {
2991 {if (true) throw (RuntimeException)jjte000;}
2992 }
2993 if (jjte000 instanceof ParseException) {
2994 {if (true) throw (ParseException)jjte000;}
2995 }
2996 {if (true) throw (Error)jjte000;}
2997 } finally {
2998 if (jjtc000) {
2999 jjtree.closeNodeScope(jjtn000, true);
3000 jjtreeCloseNodeScope(jjtn000);
3001 }
3002 }
3003 }
3004
3005 final public void type_id() throws ParseException {
3006 declaration_specifiers();
3007 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3008 case LSQUAREBRACKET:
3009 case LPARENTHESIS:
3010 case SCOPE:
3011 case AMPERSAND:
3012 case STAR:
3013 case TEMPLATE:
3014 case ID:
3015 abstract_declarator();
3016 break;
3017 default:
3018 jj_la1[89] = jj_gen;
3019 ;
3020 }
3021 }
3022
3023 final public void declarator() throws ParseException {
3024 if (jj_2_60(2147483647)) {
3025 AstParameterTypeQualifier jjtn001 = new AstParameterTypeQualifier(JJTPARAMETERTYPEQUALIFIER);
3026 boolean jjtc001 = true;
3027 jjtree.openNodeScope(jjtn001);
3028 jjtreeOpenNodeScope(jjtn001);
3029 try {
3030 ptr_operator_seq();
3031 } catch (Throwable jjte001) {
3032 if (jjtc001) {
3033 jjtree.clearNodeScope(jjtn001);
3034 jjtc001 = false;
3035 } else {
3036 jjtree.popNode();
3037 }
3038 if (jjte001 instanceof RuntimeException) {
3039 {if (true) throw (RuntimeException)jjte001;}
3040 }
3041 if (jjte001 instanceof ParseException) {
3042 {if (true) throw (ParseException)jjte001;}
3043 }
3044 {if (true) throw (Error)jjte001;}
3045 } finally {
3046 if (jjtc001) {
3047 jjtree.closeNodeScope(jjtn001, true);
3048 jjtreeCloseNodeScope(jjtn001);
3049 }
3050 }
3051 } else {
3052 ;
3053 }
3054 direct_declarator();
3055 }
3056
3057 final public void ptr_operator_seq() throws ParseException {
3058 label_21:
3059 while (true) {
3060 ptr_operator();
3061 if (jj_2_61(2147483647)) {
3062 ;
3063 } else {
3064 break label_21;
3065 }
3066 }
3067 }
3068
3069 final public void direct_declarator() throws ParseException {
3070 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3071 case SCOPE:
3072 case TEMPLATE:
3073 case OPERATOR:
3074 case ID:
3075 qualified_id();
3076 break;
3077 case LPARENTHESIS:
3078 AstParameterTypeQualifier jjtn001 = new AstParameterTypeQualifier(JJTPARAMETERTYPEQUALIFIER);
3079 boolean jjtc001 = true;
3080 jjtree.openNodeScope(jjtn001);
3081 jjtreeOpenNodeScope(jjtn001);
3082 try {
3083 jj_consume_token(LPARENTHESIS);
3084 } finally {
3085 if (jjtc001) {
3086 jjtree.closeNodeScope(jjtn001, true);
3087 jjtreeCloseNodeScope(jjtn001);
3088 }
3089 }
3090 declarator();
3091 AstParameterTypeQualifier jjtn002 = new AstParameterTypeQualifier(JJTPARAMETERTYPEQUALIFIER);
3092 boolean jjtc002 = true;
3093 jjtree.openNodeScope(jjtn002);
3094 jjtreeOpenNodeScope(jjtn002);
3095 try {
3096 jj_consume_token(RPARENTHESIS);
3097 } finally {
3098 if (jjtc002) {
3099 jjtree.closeNodeScope(jjtn002, true);
3100 jjtreeCloseNodeScope(jjtn002);
3101 }
3102 }
3103 break;
3104 default:
3105 jj_la1[90] = jj_gen;
3106 jj_consume_token(-1);
3107 throw new ParseException();
3108 }
3109 if (jj_2_62(2147483647)) {
3110 declarator_suffixes();
3111 } else {
3112 ;
3113 }
3114 }
3115
3116 final public void declarator_suffixes() throws ParseException {
3117 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3118 case LPARENTHESIS:
3119 function_parameters();
3120 cv_qualifier_seq();
3121 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3122 case THROW:
3123 exception_spec();
3124 break;
3125 default:
3126 jj_la1[91] = jj_gen;
3127 ;
3128 }
3129 break;
3130 case LSQUAREBRACKET:
3131 AstParameterTypeQualifier jjtn001 = new AstParameterTypeQualifier(JJTPARAMETERTYPEQUALIFIER);
3132 boolean jjtc001 = true;
3133 jjtree.openNodeScope(jjtn001);
3134 jjtreeOpenNodeScope(jjtn001);
3135 try {
3136 label_22:
3137 while (true) {
3138 jj_consume_token(LSQUAREBRACKET);
3139 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3140 case LPARENTHESIS:
3141 case SCOPE:
3142 case AMPERSAND:
3143 case PLUS:
3144 case MINUS:
3145 case STAR:
3146 case PLUSPLUS:
3147 case MINUSMINUS:
3148 case TILDE:
3149 case NOT:
3150 case BOOL:
3151 case CHAR:
3152 case DELETE:
3153 case DOUBLE:
3154 case FLOAT:
3155 case INT:
3156 case LONG:
3157 case NEW:
3158 case SHORT:
3159 case SIGNED:
3160 case SIZEOF:
3161 case TEMPLATE:
3162 case THIS:
3163 case TYPEID:
3164 case UNSIGNED:
3165 case VOID:
3166 case WCHAR_T:
3167 case OPERATOR:
3168 case TRUETOK:
3169 case FALSETOK:
3170 case OCTALINT:
3171 case OCTALLONG:
3172 case UNSIGNED_OCTALINT:
3173 case UNSIGNED_OCTALLONG:
3174 case DECIMALINT:
3175 case DECIMALLONG:
3176 case UNSIGNED_DECIMALINT:
3177 case UNSIGNED_DECIMALLONG:
3178 case HEXADECIMALINT:
3179 case HEXADECIMALLONG:
3180 case UNSIGNED_HEXADECIMALINT:
3181 case UNSIGNED_HEXADECIMALLONG:
3182 case FLOATONE:
3183 case FLOATTWO:
3184 case CHARACTER:
3185 case STRING:
3186 case ID:
3187 constant_expression();
3188 break;
3189 default:
3190 jj_la1[92] = jj_gen;
3191 ;
3192 }
3193 jj_consume_token(RSQUAREBRACKET);
3194 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3195 case LSQUAREBRACKET:
3196 ;
3197 break;
3198 default:
3199 jj_la1[93] = jj_gen;
3200 break label_22;
3201 }
3202 }
3203 } catch (Throwable jjte001) {
3204 if (jjtc001) {
3205 jjtree.clearNodeScope(jjtn001);
3206 jjtc001 = false;
3207 } else {
3208 jjtree.popNode();
3209 }
3210 if (jjte001 instanceof RuntimeException) {
3211 {if (true) throw (RuntimeException)jjte001;}
3212 }
3213 if (jjte001 instanceof ParseException) {
3214 {if (true) throw (ParseException)jjte001;}
3215 }
3216 {if (true) throw (Error)jjte001;}
3217 } finally {
3218 if (jjtc001) {
3219 jjtree.closeNodeScope(jjtn001, true);
3220 jjtreeCloseNodeScope(jjtn001);
3221 }
3222 }
3223 break;
3224 default:
3225 jj_la1[94] = jj_gen;
3226 jj_consume_token(-1);
3227 throw new ParseException();
3228 }
3229 }
3230
3231 final public void abstract_declarator() throws ParseException {
3232 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3233 case SCOPE:
3234 case AMPERSAND:
3235 case STAR:
3236 case TEMPLATE:
3237 case ID:
3238 ptr_operator();
3239 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3240 case LSQUAREBRACKET:
3241 case LPARENTHESIS:
3242 case SCOPE:
3243 case AMPERSAND:
3244 case STAR:
3245 case TEMPLATE:
3246 case ID:
3247 abstract_declarator();
3248 break;
3249 default:
3250 jj_la1[95] = jj_gen;
3251 ;
3252 }
3253 break;
3254 default:
3255 jj_la1[98] = jj_gen;
3256 if (jj_2_63(2147483647)) {
3257 label_23:
3258 while (true) {
3259 abstract_declarator_suffix();
3260 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3261 case LSQUAREBRACKET:
3262 case LPARENTHESIS:
3263 ;
3264 break;
3265 default:
3266 jj_la1[96] = jj_gen;
3267 break label_23;
3268 }
3269 }
3270 } else {
3271 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3272 case LPARENTHESIS:
3273 jj_consume_token(LPARENTHESIS);
3274 abstract_declarator();
3275 jj_consume_token(RPARENTHESIS);
3276 label_24:
3277 while (true) {
3278 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3279 case LSQUAREBRACKET:
3280 case LPARENTHESIS:
3281 ;
3282 break;
3283 default:
3284 jj_la1[97] = jj_gen;
3285 break label_24;
3286 }
3287 abstract_declarator_suffix();
3288 }
3289 break;
3290 default:
3291 jj_la1[99] = jj_gen;
3292 jj_consume_token(-1);
3293 throw new ParseException();
3294 }
3295 }
3296 }
3297 }
3298
3299 final public void abstract_declarator_suffix() throws ParseException {
3300 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3301 case LPARENTHESIS:
3302 function_parameters();
3303 cv_qualifier_seq();
3304 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3305 case THROW:
3306 exception_spec();
3307 break;
3308 default:
3309 jj_la1[100] = jj_gen;
3310 ;
3311 }
3312 break;
3313 case LSQUAREBRACKET:
3314 jj_consume_token(LSQUAREBRACKET);
3315 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3316 case LPARENTHESIS:
3317 case SCOPE:
3318 case AMPERSAND:
3319 case PLUS:
3320 case MINUS:
3321 case STAR:
3322 case PLUSPLUS:
3323 case MINUSMINUS:
3324 case TILDE:
3325 case NOT:
3326 case BOOL:
3327 case CHAR:
3328 case DELETE:
3329 case DOUBLE:
3330 case FLOAT:
3331 case INT:
3332 case LONG:
3333 case NEW:
3334 case SHORT:
3335 case SIGNED:
3336 case SIZEOF:
3337 case TEMPLATE:
3338 case THIS:
3339 case TYPEID:
3340 case UNSIGNED:
3341 case VOID:
3342 case WCHAR_T:
3343 case OPERATOR:
3344 case TRUETOK:
3345 case FALSETOK:
3346 case OCTALINT:
3347 case OCTALLONG:
3348 case UNSIGNED_OCTALINT:
3349 case UNSIGNED_OCTALLONG:
3350 case DECIMALINT:
3351 case DECIMALLONG:
3352 case UNSIGNED_DECIMALINT:
3353 case UNSIGNED_DECIMALLONG:
3354 case HEXADECIMALINT:
3355 case HEXADECIMALLONG:
3356 case UNSIGNED_HEXADECIMALINT:
3357 case UNSIGNED_HEXADECIMALLONG:
3358 case FLOATONE:
3359 case FLOATTWO:
3360 case CHARACTER:
3361 case STRING:
3362 case ID:
3363 constant_expression();
3364 break;
3365 default:
3366 jj_la1[101] = jj_gen;
3367 ;
3368 }
3369 jj_consume_token(RSQUAREBRACKET);
3370 break;
3371 default:
3372 jj_la1[102] = jj_gen;
3373 jj_consume_token(-1);
3374 throw new ParseException();
3375 }
3376 }
3377
3378 final public void template_head() throws ParseException {
3379 jj_consume_token(TEMPLATE);
3380 jj_consume_token(LESSTHAN);
3381 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3382 case SCOPE:
3383 case AUTO:
3384 case BOOL:
3385 case CHAR:
3386 case CONST:
3387 case DOUBLE:
3388 case ENUM:
3389 case EXTERN:
3390 case FLOAT:
3391 case FRIEND:
3392 case INLINE:
3393 case INT:
3394 case LONG:
3395 case MUTABLE:
3396 case REGISTER:
3397 case SHORT:
3398 case SIGNED:
3399 case STATIC:
3400 case STRUCT:
3401 case CLASS:
3402 case TEMPLATE:
3403 case TYPEDEF:
3404 case TYPENAME:
3405 case UNION:
3406 case UNSIGNED:
3407 case VIRTUAL:
3408 case VOID:
3409 case VOLATILE:
3410 case WCHAR_T:
3411 case ID:
3412 template_parameter_list();
3413 break;
3414 default:
3415 jj_la1[103] = jj_gen;
3416 ;
3417 }
3418 jj_consume_token(GREATERTHAN);
3419 }
3420
3421 final public void template_parameter_list() throws ParseException {
3422 template_parameter();
3423 label_25:
3424 while (true) {
3425 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3426 case COMMA:
3427 ;
3428 break;
3429 default:
3430 jj_la1[104] = jj_gen;
3431 break label_25;
3432 }
3433 jj_consume_token(COMMA);
3434 template_parameter();
3435 }
3436 }
3437
3438 final public void template_parameter() throws ParseException {
3439 if (jj_2_64(3)) {
3440 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3441 case CLASS:
3442 jj_consume_token(CLASS);
3443 break;
3444 case TYPENAME:
3445 jj_consume_token(TYPENAME);
3446 break;
3447 default:
3448 jj_la1[105] = jj_gen;
3449 jj_consume_token(-1);
3450 throw new ParseException();
3451 }
3452 jj_consume_token(ID);
3453 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3454 case ASSIGNEQUAL:
3455 jj_consume_token(ASSIGNEQUAL);
3456 parameter_declaration();
3457 break;
3458 default:
3459 jj_la1[106] = jj_gen;
3460 ;
3461 }
3462 } else {
3463 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3464 case SCOPE:
3465 case AUTO:
3466 case BOOL:
3467 case CHAR:
3468 case CONST:
3469 case DOUBLE:
3470 case ENUM:
3471 case EXTERN:
3472 case FLOAT:
3473 case FRIEND:
3474 case INLINE:
3475 case INT:
3476 case LONG:
3477 case MUTABLE:
3478 case REGISTER:
3479 case SHORT:
3480 case SIGNED:
3481 case STATIC:
3482 case STRUCT:
3483 case CLASS:
3484 case TEMPLATE:
3485 case TYPEDEF:
3486 case TYPENAME:
3487 case UNION:
3488 case UNSIGNED:
3489 case VIRTUAL:
3490 case VOID:
3491 case VOLATILE:
3492 case WCHAR_T:
3493 case ID:
3494 parameter_declaration();
3495 break;
3496 default:
3497 jj_la1[107] = jj_gen;
3498 jj_consume_token(-1);
3499 throw new ParseException();
3500 }
3501 }
3502 }
3503
3504 final public void template_argument_list() throws ParseException {
3505 jj_consume_token(LESSTHAN);
3506 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3507 case LPARENTHESIS:
3508 case SCOPE:
3509 case AMPERSAND:
3510 case PLUS:
3511 case MINUS:
3512 case STAR:
3513 case PLUSPLUS:
3514 case MINUSMINUS:
3515 case TILDE:
3516 case NOT:
3517 case AUTO:
3518 case BOOL:
3519 case CHAR:
3520 case CONST:
3521 case DELETE:
3522 case DOUBLE:
3523 case ENUM:
3524 case EXTERN:
3525 case FLOAT:
3526 case FRIEND:
3527 case INLINE:
3528 case INT:
3529 case LONG:
3530 case MUTABLE:
3531 case NEW:
3532 case REGISTER:
3533 case SHORT:
3534 case SIGNED:
3535 case SIZEOF:
3536 case STATIC:
3537 case STRUCT:
3538 case CLASS:
3539 case TEMPLATE:
3540 case THIS:
3541 case TYPEDEF:
3542 case TYPEID:
3543 case TYPENAME:
3544 case UNION:
3545 case UNSIGNED:
3546 case VIRTUAL:
3547 case VOID:
3548 case VOLATILE:
3549 case WCHAR_T:
3550 case OPERATOR:
3551 case TRUETOK:
3552 case FALSETOK:
3553 case OCTALINT:
3554 case OCTALLONG:
3555 case UNSIGNED_OCTALINT:
3556 case UNSIGNED_OCTALLONG:
3557 case DECIMALINT:
3558 case DECIMALLONG:
3559 case UNSIGNED_DECIMALINT:
3560 case UNSIGNED_DECIMALLONG:
3561 case HEXADECIMALINT:
3562 case HEXADECIMALLONG:
3563 case UNSIGNED_HEXADECIMALINT:
3564 case UNSIGNED_HEXADECIMALLONG:
3565 case FLOATONE:
3566 case FLOATTWO:
3567 case CHARACTER:
3568 case STRING:
3569 case ID:
3570 template_argument();
3571 label_26:
3572 while (true) {
3573 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3574 case COMMA:
3575 ;
3576 break;
3577 default:
3578 jj_la1[108] = jj_gen;
3579 break label_26;
3580 }
3581 jj_consume_token(COMMA);
3582 template_argument();
3583 }
3584 break;
3585 default:
3586 jj_la1[109] = jj_gen;
3587 ;
3588 }
3589 jj_consume_token(GREATERTHAN);
3590 }
3591
3592 final public void template_argument() throws ParseException {
3593 if (jj_2_65(2147483647)) {
3594 type_id();
3595 } else {
3596 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3597 case LPARENTHESIS:
3598 case SCOPE:
3599 case AMPERSAND:
3600 case PLUS:
3601 case MINUS:
3602 case STAR:
3603 case PLUSPLUS:
3604 case MINUSMINUS:
3605 case TILDE:
3606 case NOT:
3607 case BOOL:
3608 case CHAR:
3609 case DELETE:
3610 case DOUBLE:
3611 case FLOAT:
3612 case INT:
3613 case LONG:
3614 case NEW:
3615 case SHORT:
3616 case SIGNED:
3617 case SIZEOF:
3618 case TEMPLATE:
3619 case THIS:
3620 case TYPEID:
3621 case UNSIGNED:
3622 case VOID:
3623 case WCHAR_T:
3624 case OPERATOR:
3625 case TRUETOK:
3626 case FALSETOK:
3627 case OCTALINT:
3628 case OCTALLONG:
3629 case UNSIGNED_OCTALINT:
3630 case UNSIGNED_OCTALLONG:
3631 case DECIMALINT:
3632 case DECIMALLONG:
3633 case UNSIGNED_DECIMALINT:
3634 case UNSIGNED_DECIMALLONG:
3635 case HEXADECIMALINT:
3636 case HEXADECIMALLONG:
3637 case UNSIGNED_HEXADECIMALINT:
3638 case UNSIGNED_HEXADECIMALLONG:
3639 case FLOATONE:
3640 case FLOATTWO:
3641 case CHARACTER:
3642 case STRING:
3643 case ID:
3644 additive_expression();
3645 break;
3646 default:
3647 jj_la1[110] = jj_gen;
3648 jj_consume_token(-1);
3649 throw new ParseException();
3650 }
3651 }
3652 }
3653
3654 final public void statement_list() throws ParseException {
3655 label_27:
3656 while (true) {
3657 statement();
3658 if (jj_2_66(2147483647)) {
3659 ;
3660 } else {
3661 break label_27;
3662 }
3663 }
3664 }
3665
3666 final public void statement() throws ParseException {
3667 if (jj_2_67(2147483647)) {
3668 labeled_statement();
3669 } else if (jj_2_68(2147483647)) {
3670 AstExpressionStatement jjtn001 = new AstExpressionStatement(JJTEXPRESSIONSTATEMENT);
3671 boolean jjtc001 = true;
3672 jjtree.openNodeScope(jjtn001);
3673 jjtreeOpenNodeScope(jjtn001);
3674 try {
3675 expression();
3676 jj_consume_token(SEMICOLON);
3677 } catch (Throwable jjte001) {
3678 if (jjtc001) {
3679 jjtree.clearNodeScope(jjtn001);
3680 jjtc001 = false;
3681 } else {
3682 jjtree.popNode();
3683 }
3684 if (jjte001 instanceof RuntimeException) {
3685 {if (true) throw (RuntimeException)jjte001;}
3686 }
3687 if (jjte001 instanceof ParseException) {
3688 {if (true) throw (ParseException)jjte001;}
3689 }
3690 {if (true) throw (Error)jjte001;}
3691 } finally {
3692 if (jjtc001) {
3693 jjtree.closeNodeScope(jjtn001, true);
3694 jjtreeCloseNodeScope(jjtn001);
3695 }
3696 }
3697 } else {
3698 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3699 case LCURLYBRACE:
3700 compound_statement();
3701 break;
3702 case IF:
3703 case SWITCH:
3704 selection_statement();
3705 break;
3706 case DO:
3707 case FOR:
3708 case WHILE:
3709 iteration_statement();
3710 break;
3711 case BREAK:
3712 case CONTINUE:
3713 case GOTO:
3714 case RETURN:
3715 jump_statement();
3716 jj_consume_token(SEMICOLON);
3717 break;
3718 case SCOPE:
3719 case AUTO:
3720 case BOOL:
3721 case CHAR:
3722 case CONST:
3723 case DOUBLE:
3724 case ENUM:
3725 case EXTERN:
3726 case FLOAT:
3727 case FRIEND:
3728 case INLINE:
3729 case INT:
3730 case LONG:
3731 case MUTABLE:
3732 case NAMESPACE:
3733 case REGISTER:
3734 case SHORT:
3735 case SIGNED:
3736 case STATIC:
3737 case STRUCT:
3738 case CLASS:
3739 case TEMPLATE:
3740 case TYPEDEF:
3741 case TYPENAME:
3742 case UNION:
3743 case UNSIGNED:
3744 case USING:
3745 case VIRTUAL:
3746 case VOID:
3747 case VOLATILE:
3748 case WCHAR_T:
3749 case ID:
3750 AstDeclarationStatement jjtn002 = new AstDeclarationStatement(JJTDECLARATIONSTATEMENT);
3751 boolean jjtc002 = true;
3752 jjtree.openNodeScope(jjtn002);
3753 jjtreeOpenNodeScope(jjtn002);
3754 try {
3755 block_declaration();
3756 } catch (Throwable jjte002) {
3757 if (jjtc002) {
3758 jjtree.clearNodeScope(jjtn002);
3759 jjtc002 = false;
3760 } else {
3761 jjtree.popNode();
3762 }
3763 if (jjte002 instanceof RuntimeException) {
3764 {if (true) throw (RuntimeException)jjte002;}
3765 }
3766 if (jjte002 instanceof ParseException) {
3767 {if (true) throw (ParseException)jjte002;}
3768 }
3769 {if (true) throw (Error)jjte002;}
3770 } finally {
3771 if (jjtc002) {
3772 jjtree.closeNodeScope(jjtn002, true);
3773 jjtreeCloseNodeScope(jjtn002);
3774 }
3775 }
3776 break;
3777 case TRY:
3778 try_block();
3779 label_28:
3780 while (true) {
3781 handler();
3782 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3783 case CATCH:
3784 ;
3785 break;
3786 default:
3787 jj_la1[111] = jj_gen;
3788 break label_28;
3789 }
3790 }
3791 break;
3792 case SEMICOLON:
3793 jj_consume_token(SEMICOLON);
3794 break;
3795 default:
3796 jj_la1[112] = jj_gen;
3797 jj_consume_token(-1);
3798 throw new ParseException();
3799 }
3800 }
3801 }
3802
3803 final public void block_declaration() throws ParseException {
3804 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3805 case SCOPE:
3806 case AUTO:
3807 case BOOL:
3808 case CHAR:
3809 case CONST:
3810 case DOUBLE:
3811 case ENUM:
3812 case EXTERN:
3813 case FLOAT:
3814 case FRIEND:
3815 case INLINE:
3816 case INT:
3817 case LONG:
3818 case MUTABLE:
3819 case REGISTER:
3820 case SHORT:
3821 case SIGNED:
3822 case STATIC:
3823 case STRUCT:
3824 case CLASS:
3825 case TEMPLATE:
3826 case TYPEDEF:
3827 case TYPENAME:
3828 case UNION:
3829 case UNSIGNED:
3830 case VIRTUAL:
3831 case VOID:
3832 case VOLATILE:
3833 case WCHAR_T:
3834 case ID:
3835 simple_declaration();
3836 break;
3837 case NAMESPACE:
3838 namespace_alias_definition();
3839 break;
3840 default:
3841 jj_la1[113] = jj_gen;
3842 if (jj_2_69(2147483647)) {
3843 using_directive();
3844 } else if (jj_2_70(2147483647)) {
3845 using_declaration();
3846 } else {
3847 jj_consume_token(-1);
3848 throw new ParseException();
3849 }
3850 }
3851 }
3852
3853 final public void simple_declaration() throws ParseException {
3854 declaration_specifiers();
3855 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3856 case LPARENTHESIS:
3857 case SCOPE:
3858 case AMPERSAND:
3859 case STAR:
3860 case TEMPLATE:
3861 case OPERATOR:
3862 case ID:
3863 init_declarator_list();
3864 break;
3865 default:
3866 jj_la1[114] = jj_gen;
3867 ;
3868 }
3869 jj_consume_token(SEMICOLON);
3870 }
3871
3872 final public void namespace_alias_definition() throws ParseException {
3873
3874 AstNamespaceAliasDefinition jjtn000 = new AstNamespaceAliasDefinition(JJTNAMESPACEALIASDEFINITION);
3875 boolean jjtc000 = true;
3876 jjtree.openNodeScope(jjtn000);
3877 jjtreeOpenNodeScope(jjtn000);
3878 try {
3879 jj_consume_token(NAMESPACE);
3880 jj_consume_token(ID);
3881 jj_consume_token(ASSIGNEQUAL);
3882 qualified_type();
3883 jj_consume_token(SEMICOLON);
3884 } catch (Throwable jjte000) {
3885 if (jjtc000) {
3886 jjtree.clearNodeScope(jjtn000);
3887 jjtc000 = false;
3888 } else {
3889 jjtree.popNode();
3890 }
3891 if (jjte000 instanceof RuntimeException) {
3892 {if (true) throw (RuntimeException)jjte000;}
3893 }
3894 if (jjte000 instanceof ParseException) {
3895 {if (true) throw (ParseException)jjte000;}
3896 }
3897 {if (true) throw (Error)jjte000;}
3898 } finally {
3899 if (jjtc000) {
3900 jjtree.closeNodeScope(jjtn000, true);
3901 jjtreeCloseNodeScope(jjtn000);
3902 }
3903 }
3904 }
3905
3906 final public void labeled_statement() throws ParseException {
3907 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3908 case ID:
3909 AstLabelStatement jjtn001 = new AstLabelStatement(JJTLABELSTATEMENT);
3910 boolean jjtc001 = true;
3911 jjtree.openNodeScope(jjtn001);
3912 jjtreeOpenNodeScope(jjtn001);
3913 try {
3914 jj_consume_token(ID);
3915 jj_consume_token(COLON);
3916 statement();
3917 } catch (Throwable jjte001) {
3918 if (jjtc001) {
3919 jjtree.clearNodeScope(jjtn001);
3920 jjtc001 = false;
3921 } else {
3922 jjtree.popNode();
3923 }
3924 if (jjte001 instanceof RuntimeException) {
3925 {if (true) throw (RuntimeException)jjte001;}
3926 }
3927 if (jjte001 instanceof ParseException) {
3928 {if (true) throw (ParseException)jjte001;}
3929 }
3930 {if (true) throw (Error)jjte001;}
3931 } finally {
3932 if (jjtc001) {
3933 jjtree.closeNodeScope(jjtn001, true);
3934 jjtreeCloseNodeScope(jjtn001);
3935 }
3936 }
3937 break;
3938 case CASE:
3939 AstCaseStatement jjtn002 = new AstCaseStatement(JJTCASESTATEMENT);
3940 boolean jjtc002 = true;
3941 jjtree.openNodeScope(jjtn002);
3942 jjtreeOpenNodeScope(jjtn002);
3943 try {
3944 jj_consume_token(CASE);
3945 constant_expression();
3946 jj_consume_token(COLON);
3947 statement();
3948 } catch (Throwable jjte002) {
3949 if (jjtc002) {
3950 jjtree.clearNodeScope(jjtn002);
3951 jjtc002 = false;
3952 } else {
3953 jjtree.popNode();
3954 }
3955 if (jjte002 instanceof RuntimeException) {
3956 {if (true) throw (RuntimeException)jjte002;}
3957 }
3958 if (jjte002 instanceof ParseException) {
3959 {if (true) throw (ParseException)jjte002;}
3960 }
3961 {if (true) throw (Error)jjte002;}
3962 } finally {
3963 if (jjtc002) {
3964 jjtree.closeNodeScope(jjtn002, true);
3965 jjtreeCloseNodeScope(jjtn002);
3966 }
3967 }
3968 break;
3969 case _DEFAULT:
3970 AstDefaultStatement jjtn003 = new AstDefaultStatement(JJTDEFAULTSTATEMENT);
3971 boolean jjtc003 = true;
3972 jjtree.openNodeScope(jjtn003);
3973 jjtreeOpenNodeScope(jjtn003);
3974 try {
3975 jj_consume_token(_DEFAULT);
3976 jj_consume_token(COLON);
3977 statement();
3978 } catch (Throwable jjte003) {
3979 if (jjtc003) {
3980 jjtree.clearNodeScope(jjtn003);
3981 jjtc003 = false;
3982 } else {
3983 jjtree.popNode();
3984 }
3985 if (jjte003 instanceof RuntimeException) {
3986 {if (true) throw (RuntimeException)jjte003;}
3987 }
3988 if (jjte003 instanceof ParseException) {
3989 {if (true) throw (ParseException)jjte003;}
3990 }
3991 {if (true) throw (Error)jjte003;}
3992 } finally {
3993 if (jjtc003) {
3994 jjtree.closeNodeScope(jjtn003, true);
3995 jjtreeCloseNodeScope(jjtn003);
3996 }
3997 }
3998 break;
3999 default:
4000 jj_la1[115] = jj_gen;
4001 jj_consume_token(-1);
4002 throw new ParseException();
4003 }
4004 }
4005
4006 final public void compound_statement() throws ParseException {
4007 jj_consume_token(LCURLYBRACE);
4008 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4009 case LCURLYBRACE:
4010 case LPARENTHESIS:
4011 case SCOPE:
4012 case SEMICOLON:
4013 case AMPERSAND:
4014 case PLUS:
4015 case MINUS:
4016 case STAR:
4017 case PLUSPLUS:
4018 case MINUSMINUS:
4019 case TILDE:
4020 case NOT:
4021 case AUTO:
4022 case BOOL:
4023 case BREAK:
4024 case CASE:
4025 case CHAR:
4026 case CONST:
4027 case CONTINUE:
4028 case _DEFAULT:
4029 case DELETE:
4030 case DO:
4031 case DOUBLE:
4032 case ENUM:
4033 case EXTERN:
4034 case FLOAT:
4035 case FOR:
4036 case FRIEND:
4037 case GOTO:
4038 case IF:
4039 case INLINE:
4040 case INT:
4041 case LONG:
4042 case MUTABLE:
4043 case NAMESPACE:
4044 case NEW:
4045 case REGISTER:
4046 case RETURN:
4047 case SHORT:
4048 case SIGNED:
4049 case SIZEOF:
4050 case STATIC:
4051 case STRUCT:
4052 case CLASS:
4053 case SWITCH:
4054 case TEMPLATE:
4055 case THIS:
4056 case TRY:
4057 case TYPEDEF:
4058 case TYPEID:
4059 case TYPENAME:
4060 case UNION:
4061 case UNSIGNED:
4062 case USING:
4063 case VIRTUAL:
4064 case VOID:
4065 case VOLATILE:
4066 case WCHAR_T:
4067 case WHILE:
4068 case OPERATOR:
4069 case TRUETOK:
4070 case FALSETOK:
4071 case THROW:
4072 case OCTALINT:
4073 case OCTALLONG:
4074 case UNSIGNED_OCTALINT:
4075 case UNSIGNED_OCTALLONG:
4076 case DECIMALINT:
4077 case DECIMALLONG:
4078 case UNSIGNED_DECIMALINT:
4079 case UNSIGNED_DECIMALLONG:
4080 case HEXADECIMALINT:
4081 case HEXADECIMALLONG:
4082 case UNSIGNED_HEXADECIMALINT:
4083 case UNSIGNED_HEXADECIMALLONG:
4084 case FLOATONE:
4085 case FLOATTWO:
4086 case CHARACTER:
4087 case STRING:
4088 case ID:
4089 statement_list();
4090 break;
4091 default:
4092 jj_la1[116] = jj_gen;
4093 ;
4094 }
4095 jj_consume_token(RCURLYBRACE);
4096 }
4097
4098 final public void selection_statement() throws ParseException {
4099 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4100 case IF:
4101 AstIfStatement jjtn002 = new AstIfStatement(JJTIFSTATEMENT);
4102 boolean jjtc002 = true;
4103 jjtree.openNodeScope(jjtn002);
4104 jjtreeOpenNodeScope(jjtn002);
4105 try {
4106 jj_consume_token(IF);
4107 jj_consume_token(LPARENTHESIS);
4108 condition();
4109 jj_consume_token(RPARENTHESIS);
4110 statement();
4111 if (jj_2_71(2147483647)) {
4112 jj_consume_token(ELSE);
4113 AstElseStatement jjtn001 = new AstElseStatement(JJTELSESTATEMENT);
4114 boolean jjtc001 = true;
4115 jjtree.openNodeScope(jjtn001);
4116 jjtreeOpenNodeScope(jjtn001);
4117 try {
4118 statement();
4119 } catch (Throwable jjte001) {
4120 if (jjtc001) {
4121 jjtree.clearNodeScope(jjtn001);
4122 jjtc001 = false;
4123 } else {
4124 jjtree.popNode();
4125 }
4126 if (jjte001 instanceof RuntimeException) {
4127 {if (true) throw (RuntimeException)jjte001;}
4128 }
4129 if (jjte001 instanceof ParseException) {
4130 {if (true) throw (ParseException)jjte001;}
4131 }
4132 {if (true) throw (Error)jjte001;}
4133 } finally {
4134 if (jjtc001) {
4135 jjtree.closeNodeScope(jjtn001, true);
4136 jjtreeCloseNodeScope(jjtn001);
4137 }
4138 }
4139 } else {
4140 ;
4141 }
4142 } catch (Throwable jjte002) {
4143 if (jjtc002) {
4144 jjtree.clearNodeScope(jjtn002);
4145 jjtc002 = false;
4146 } else {
4147 jjtree.popNode();
4148 }
4149 if (jjte002 instanceof RuntimeException) {
4150 {if (true) throw (RuntimeException)jjte002;}
4151 }
4152 if (jjte002 instanceof ParseException) {
4153 {if (true) throw (ParseException)jjte002;}
4154 }
4155 {if (true) throw (Error)jjte002;}
4156 } finally {
4157 if (jjtc002) {
4158 jjtree.closeNodeScope(jjtn002, true);
4159 jjtreeCloseNodeScope(jjtn002);
4160 }
4161 }
4162 break;
4163 case SWITCH:
4164 AstSwitchStatement jjtn003 = new AstSwitchStatement(JJTSWITCHSTATEMENT);
4165 boolean jjtc003 = true;
4166 jjtree.openNodeScope(jjtn003);
4167 jjtreeOpenNodeScope(jjtn003);
4168 try {
4169 jj_consume_token(SWITCH);
4170 jj_consume_token(LPARENTHESIS);
4171 condition();
4172 jj_consume_token(RPARENTHESIS);
4173 statement();
4174 } catch (Throwable jjte003) {
4175 if (jjtc003) {
4176 jjtree.clearNodeScope(jjtn003);
4177 jjtc003 = false;
4178 } else {
4179 jjtree.popNode();
4180 }
4181 if (jjte003 instanceof RuntimeException) {
4182 {if (true) throw (RuntimeException)jjte003;}
4183 }
4184 if (jjte003 instanceof ParseException) {
4185 {if (true) throw (ParseException)jjte003;}
4186 }
4187 {if (true) throw (Error)jjte003;}
4188 } finally {
4189 if (jjtc003) {
4190 jjtree.closeNodeScope(jjtn003, true);
4191 jjtreeCloseNodeScope(jjtn003);
4192 }
4193 }
4194 break;
4195 default:
4196 jj_la1[117] = jj_gen;
4197 jj_consume_token(-1);
4198 throw new ParseException();
4199 }
4200 }
4201
4202 final public void iteration_statement() throws ParseException {
4203
4204 AstIterationStatement jjtn000 = new AstIterationStatement(JJTITERATIONSTATEMENT);
4205 boolean jjtc000 = true;
4206 jjtree.openNodeScope(jjtn000);
4207 jjtreeOpenNodeScope(jjtn000);
4208 try {
4209 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4210 case WHILE:
4211 jj_consume_token(WHILE);
4212 jj_consume_token(LPARENTHESIS);
4213 condition();
4214 jj_consume_token(RPARENTHESIS);
4215 statement();
4216 break;
4217 case DO:
4218 jj_consume_token(DO);
4219 statement();
4220 jj_consume_token(WHILE);
4221 jj_consume_token(LPARENTHESIS);
4222 condition();
4223 jj_consume_token(RPARENTHESIS);
4224 jj_consume_token(SEMICOLON);
4225 break;
4226 case FOR:
4227 jj_consume_token(FOR);
4228 jj_consume_token(LPARENTHESIS);
4229 if (jj_2_72(2147483647)) {
4230 simple_declaration();
4231 } else {
4232 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4233 case LPARENTHESIS:
4234 case SCOPE:
4235 case SEMICOLON:
4236 case AMPERSAND:
4237 case PLUS:
4238 case MINUS:
4239 case STAR:
4240 case PLUSPLUS:
4241 case MINUSMINUS:
4242 case TILDE:
4243 case NOT:
4244 case BOOL:
4245 case CHAR:
4246 case DELETE:
4247 case DOUBLE:
4248 case FLOAT:
4249 case INT:
4250 case LONG:
4251 case NEW:
4252 case SHORT:
4253 case SIGNED:
4254 case SIZEOF:
4255 case TEMPLATE:
4256 case THIS:
4257 case TYPEID:
4258 case UNSIGNED:
4259 case VOID:
4260 case WCHAR_T:
4261 case OPERATOR:
4262 case TRUETOK:
4263 case FALSETOK:
4264 case THROW:
4265 case OCTALINT:
4266 case OCTALLONG:
4267 case UNSIGNED_OCTALINT:
4268 case UNSIGNED_OCTALLONG:
4269 case DECIMALINT:
4270 case DECIMALLONG:
4271 case UNSIGNED_DECIMALINT:
4272 case UNSIGNED_DECIMALLONG:
4273 case HEXADECIMALINT:
4274 case HEXADECIMALLONG:
4275 case UNSIGNED_HEXADECIMALINT:
4276 case UNSIGNED_HEXADECIMALLONG:
4277 case FLOATONE:
4278 case FLOATTWO:
4279 case CHARACTER:
4280 case STRING:
4281 case ID:
4282 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4283 case LPARENTHESIS:
4284 case SCOPE:
4285 case AMPERSAND:
4286 case PLUS:
4287 case MINUS:
4288 case STAR:
4289 case PLUSPLUS:
4290 case MINUSMINUS:
4291 case TILDE:
4292 case NOT:
4293 case BOOL:
4294 case CHAR:
4295 case DELETE:
4296 case DOUBLE:
4297 case FLOAT:
4298 case INT:
4299 case LONG:
4300 case NEW:
4301 case SHORT:
4302 case SIGNED:
4303 case SIZEOF:
4304 case TEMPLATE:
4305 case THIS:
4306 case TYPEID:
4307 case UNSIGNED:
4308 case VOID:
4309 case WCHAR_T:
4310 case OPERATOR:
4311 case TRUETOK:
4312 case FALSETOK:
4313 case THROW:
4314 case OCTALINT:
4315 case OCTALLONG:
4316 case UNSIGNED_OCTALINT:
4317 case UNSIGNED_OCTALLONG:
4318 case DECIMALINT:
4319 case DECIMALLONG:
4320 case UNSIGNED_DECIMALINT:
4321 case UNSIGNED_DECIMALLONG:
4322 case HEXADECIMALINT:
4323 case HEXADECIMALLONG:
4324 case UNSIGNED_HEXADECIMALINT:
4325 case UNSIGNED_HEXADECIMALLONG:
4326 case FLOATONE:
4327 case FLOATTWO:
4328 case CHARACTER:
4329 case STRING:
4330 case ID:
4331 expression();
4332 break;
4333 default:
4334 jj_la1[118] = jj_gen;
4335 ;
4336 }
4337 jj_consume_token(SEMICOLON);
4338 break;
4339 default:
4340 jj_la1[119] = jj_gen;
4341 jj_consume_token(-1);
4342 throw new ParseException();
4343 }
4344 }
4345 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4346 case LPARENTHESIS:
4347 case SCOPE:
4348 case AMPERSAND:
4349 case PLUS:
4350 case MINUS:
4351 case STAR:
4352 case PLUSPLUS:
4353 case MINUSMINUS:
4354 case TILDE:
4355 case NOT:
4356 case AUTO:
4357 case BOOL:
4358 case CHAR:
4359 case CONST:
4360 case DELETE:
4361 case DOUBLE:
4362 case ENUM:
4363 case EXTERN:
4364 case FLOAT:
4365 case FRIEND:
4366 case INLINE:
4367 case INT:
4368 case LONG:
4369 case MUTABLE:
4370 case NEW:
4371 case REGISTER:
4372 case SHORT:
4373 case SIGNED:
4374 case SIZEOF:
4375 case STATIC:
4376 case STRUCT:
4377 case CLASS:
4378 case TEMPLATE:
4379 case THIS:
4380 case TYPEDEF:
4381 case TYPEID:
4382 case TYPENAME:
4383 case UNION:
4384 case UNSIGNED:
4385 case VIRTUAL:
4386 case VOID:
4387 case VOLATILE:
4388 case WCHAR_T:
4389 case OPERATOR:
4390 case TRUETOK:
4391 case FALSETOK:
4392 case THROW:
4393 case OCTALINT:
4394 case OCTALLONG:
4395 case UNSIGNED_OCTALINT:
4396 case UNSIGNED_OCTALLONG:
4397 case DECIMALINT:
4398 case DECIMALLONG:
4399 case UNSIGNED_DECIMALINT:
4400 case UNSIGNED_DECIMALLONG:
4401 case HEXADECIMALINT:
4402 case HEXADECIMALLONG:
4403 case UNSIGNED_HEXADECIMALINT:
4404 case UNSIGNED_HEXADECIMALLONG:
4405 case FLOATONE:
4406 case FLOATTWO:
4407 case CHARACTER:
4408 case STRING:
4409 case ID:
4410 condition();
4411 break;
4412 default:
4413 jj_la1[120] = jj_gen;
4414 ;
4415 }
4416 jj_consume_token(SEMICOLON);
4417 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4418 case LPARENTHESIS:
4419 case SCOPE:
4420 case AMPERSAND:
4421 case PLUS:
4422 case MINUS:
4423 case STAR:
4424 case PLUSPLUS:
4425 case MINUSMINUS:
4426 case TILDE:
4427 case NOT:
4428 case BOOL:
4429 case CHAR:
4430 case DELETE:
4431 case DOUBLE:
4432 case FLOAT:
4433 case INT:
4434 case LONG:
4435 case NEW:
4436 case SHORT:
4437 case SIGNED:
4438 case SIZEOF:
4439 case TEMPLATE:
4440 case THIS:
4441 case TYPEID:
4442 case UNSIGNED:
4443 case VOID:
4444 case WCHAR_T:
4445 case OPERATOR:
4446 case TRUETOK:
4447 case FALSETOK:
4448 case THROW:
4449 case OCTALINT:
4450 case OCTALLONG:
4451 case UNSIGNED_OCTALINT:
4452 case UNSIGNED_OCTALLONG:
4453 case DECIMALINT:
4454 case DECIMALLONG:
4455 case UNSIGNED_DECIMALINT:
4456 case UNSIGNED_DECIMALLONG:
4457 case HEXADECIMALINT:
4458 case HEXADECIMALLONG:
4459 case UNSIGNED_HEXADECIMALINT:
4460 case UNSIGNED_HEXADECIMALLONG:
4461 case FLOATONE:
4462 case FLOATTWO:
4463 case CHARACTER:
4464 case STRING:
4465 case ID:
4466 expression();
4467 break;
4468 default:
4469 jj_la1[121] = jj_gen;
4470 ;
4471 }
4472 jj_consume_token(RPARENTHESIS);
4473 statement();
4474 break;
4475 default:
4476 jj_la1[122] = jj_gen;
4477 jj_consume_token(-1);
4478 throw new ParseException();
4479 }
4480 } catch (Throwable jjte000) {
4481 if (jjtc000) {
4482 jjtree.clearNodeScope(jjtn000);
4483 jjtc000 = false;
4484 } else {
4485 jjtree.popNode();
4486 }
4487 if (jjte000 instanceof RuntimeException) {
4488 {if (true) throw (RuntimeException)jjte000;}
4489 }
4490 if (jjte000 instanceof ParseException) {
4491 {if (true) throw (ParseException)jjte000;}
4492 }
4493 {if (true) throw (Error)jjte000;}
4494 } finally {
4495 if (jjtc000) {
4496 jjtree.closeNodeScope(jjtn000, true);
4497 jjtreeCloseNodeScope(jjtn000);
4498 }
4499 }
4500 }
4501
4502 final public void condition() throws ParseException {
4503 if (jj_2_73(2147483647)) {
4504 expression();
4505 } else {
4506 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4507 case SCOPE:
4508 case AUTO:
4509 case BOOL:
4510 case CHAR:
4511 case CONST:
4512 case DOUBLE:
4513 case ENUM:
4514 case EXTERN:
4515 case FLOAT:
4516 case FRIEND:
4517 case INLINE:
4518 case INT:
4519 case LONG:
4520 case MUTABLE:
4521 case REGISTER:
4522 case SHORT:
4523 case SIGNED:
4524 case STATIC:
4525 case STRUCT:
4526 case CLASS:
4527 case TEMPLATE:
4528 case TYPEDEF:
4529 case TYPENAME:
4530 case UNION:
4531 case UNSIGNED:
4532 case VIRTUAL:
4533 case VOID:
4534 case VOLATILE:
4535 case WCHAR_T:
4536 case ID:
4537 declaration_specifiers();
4538 declarator();
4539 jj_consume_token(ASSIGNEQUAL);
4540 assignment_expression();
4541 break;
4542 default:
4543 jj_la1[123] = jj_gen;
4544 jj_consume_token(-1);
4545 throw new ParseException();
4546 }
4547 }
4548 }
4549
4550 final public void jump_statement() throws ParseException {
4551 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4552 case GOTO:
4553 AstGotoStatement jjtn001 = new AstGotoStatement(JJTGOTOSTATEMENT);
4554 boolean jjtc001 = true;
4555 jjtree.openNodeScope(jjtn001);
4556 jjtreeOpenNodeScope(jjtn001);
4557 try {
4558 jj_consume_token(GOTO);
4559 jj_consume_token(ID);
4560 } finally {
4561 if (jjtc001) {
4562 jjtree.closeNodeScope(jjtn001, true);
4563 jjtreeCloseNodeScope(jjtn001);
4564 }
4565 }
4566 break;
4567 case CONTINUE:
4568 AstContinueStatement jjtn002 = new AstContinueStatement(JJTCONTINUESTATEMENT);
4569 boolean jjtc002 = true;
4570 jjtree.openNodeScope(jjtn002);
4571 jjtreeOpenNodeScope(jjtn002);
4572 try {
4573 jj_consume_token(CONTINUE);
4574 } finally {
4575 if (jjtc002) {
4576 jjtree.closeNodeScope(jjtn002, true);
4577 jjtreeCloseNodeScope(jjtn002);
4578 }
4579 }
4580 break;
4581 case BREAK:
4582 AstBreakStatement jjtn003 = new AstBreakStatement(JJTBREAKSTATEMENT);
4583 boolean jjtc003 = true;
4584 jjtree.openNodeScope(jjtn003);
4585 jjtreeOpenNodeScope(jjtn003);
4586 try {
4587 jj_consume_token(BREAK);
4588 } finally {
4589 if (jjtc003) {
4590 jjtree.closeNodeScope(jjtn003, true);
4591 jjtreeCloseNodeScope(jjtn003);
4592 }
4593 }
4594 break;
4595 case RETURN:
4596 AstReturnStatement jjtn004 = new AstReturnStatement(JJTRETURNSTATEMENT);
4597 boolean jjtc004 = true;
4598 jjtree.openNodeScope(jjtn004);
4599 jjtreeOpenNodeScope(jjtn004);
4600 try {
4601 jj_consume_token(RETURN);
4602 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4603 case LPARENTHESIS:
4604 case SCOPE:
4605 case AMPERSAND:
4606 case PLUS:
4607 case MINUS:
4608 case STAR:
4609 case PLUSPLUS:
4610 case MINUSMINUS:
4611 case TILDE:
4612 case NOT:
4613 case BOOL:
4614 case CHAR:
4615 case DELETE:
4616 case DOUBLE:
4617 case FLOAT:
4618 case INT:
4619 case LONG:
4620 case NEW:
4621 case SHORT:
4622 case SIGNED:
4623 case SIZEOF:
4624 case TEMPLATE:
4625 case THIS:
4626 case TYPEID:
4627 case UNSIGNED:
4628 case VOID:
4629 case WCHAR_T:
4630 case OPERATOR:
4631 case TRUETOK:
4632 case FALSETOK:
4633 case THROW:
4634 case OCTALINT:
4635 case OCTALLONG:
4636 case UNSIGNED_OCTALINT:
4637 case UNSIGNED_OCTALLONG:
4638 case DECIMALINT:
4639 case DECIMALLONG:
4640 case UNSIGNED_DECIMALINT:
4641 case UNSIGNED_DECIMALLONG:
4642 case HEXADECIMALINT:
4643 case HEXADECIMALLONG:
4644 case UNSIGNED_HEXADECIMALINT:
4645 case UNSIGNED_HEXADECIMALLONG:
4646 case FLOATONE:
4647 case FLOATTWO:
4648 case CHARACTER:
4649 case STRING:
4650 case ID:
4651 expression();
4652 break;
4653 default:
4654 jj_la1[124] = jj_gen;
4655 ;
4656 }
4657 } catch (Throwable jjte004) {
4658 if (jjtc004) {
4659 jjtree.clearNodeScope(jjtn004);
4660 jjtc004 = false;
4661 } else {
4662 jjtree.popNode();
4663 }
4664 if (jjte004 instanceof RuntimeException) {
4665 {if (true) throw (RuntimeException)jjte004;}
4666 }
4667 if (jjte004 instanceof ParseException) {
4668 {if (true) throw (ParseException)jjte004;}
4669 }
4670 {if (true) throw (Error)jjte004;}
4671 } finally {
4672 if (jjtc004) {
4673 jjtree.closeNodeScope(jjtn004, true);
4674 jjtreeCloseNodeScope(jjtn004);
4675 }
4676 }
4677 break;
4678 default:
4679 jj_la1[125] = jj_gen;
4680 jj_consume_token(-1);
4681 throw new ParseException();
4682 }
4683 }
4684
4685 final public void try_block() throws ParseException {
4686
4687 AstTryBlock jjtn000 = new AstTryBlock(JJTTRYBLOCK);
4688 boolean jjtc000 = true;
4689 jjtree.openNodeScope(jjtn000);
4690 jjtreeOpenNodeScope(jjtn000);
4691 try {
4692 jj_consume_token(TRY);
4693 compound_statement();
4694 } catch (Throwable jjte000) {
4695 if (jjtc000) {
4696 jjtree.clearNodeScope(jjtn000);
4697 jjtc000 = false;
4698 } else {
4699 jjtree.popNode();
4700 }
4701 if (jjte000 instanceof RuntimeException) {
4702 {if (true) throw (RuntimeException)jjte000;}
4703 }
4704 if (jjte000 instanceof ParseException) {
4705 {if (true) throw (ParseException)jjte000;}
4706 }
4707 {if (true) throw (Error)jjte000;}
4708 } finally {
4709 if (jjtc000) {
4710 jjtree.closeNodeScope(jjtn000, true);
4711 jjtreeCloseNodeScope(jjtn000);
4712 }
4713 }
4714 }
4715
4716 final public void handler() throws ParseException {
4717
4718 AstCatchBlock jjtn000 = new AstCatchBlock(JJTCATCHBLOCK);
4719 boolean jjtc000 = true;
4720 jjtree.openNodeScope(jjtn000);
4721 jjtreeOpenNodeScope(jjtn000);
4722 try {
4723 jj_consume_token(CATCH);
4724 jj_consume_token(LPARENTHESIS);
4725 exception_declaration();
4726 jj_consume_token(RPARENTHESIS);
4727 compound_statement();
4728 } catch (Throwable jjte000) {
4729 if (jjtc000) {
4730 jjtree.clearNodeScope(jjtn000);
4731 jjtc000 = false;
4732 } else {
4733 jjtree.popNode();
4734 }
4735 if (jjte000 instanceof RuntimeException) {
4736 {if (true) throw (RuntimeException)jjte000;}
4737 }
4738 if (jjte000 instanceof ParseException) {
4739 {if (true) throw (ParseException)jjte000;}
4740 }
4741 {if (true) throw (Error)jjte000;}
4742 } finally {
4743 if (jjtc000) {
4744 jjtree.closeNodeScope(jjtn000, true);
4745 jjtreeCloseNodeScope(jjtn000);
4746 }
4747 }
4748 }
4749
4750 final public void exception_declaration() throws ParseException {
4751 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4752 case SCOPE:
4753 case AUTO:
4754 case BOOL:
4755 case CHAR:
4756 case CONST:
4757 case DOUBLE:
4758 case ENUM:
4759 case EXTERN:
4760 case FLOAT:
4761 case FRIEND:
4762 case INLINE:
4763 case INT:
4764 case LONG:
4765 case MUTABLE:
4766 case REGISTER:
4767 case SHORT:
4768 case SIGNED:
4769 case STATIC:
4770 case STRUCT:
4771 case CLASS:
4772 case TEMPLATE:
4773 case TYPEDEF:
4774 case TYPENAME:
4775 case UNION:
4776 case UNSIGNED:
4777 case VIRTUAL:
4778 case VOID:
4779 case VOLATILE:
4780 case WCHAR_T:
4781 case ID:
4782 parameter_declaration();
4783 break;
4784 case ELLIPSIS:
4785 jj_consume_token(ELLIPSIS);
4786 break;
4787 default:
4788 jj_la1[126] = jj_gen;
4789 jj_consume_token(-1);
4790 throw new ParseException();
4791 }
4792 }
4793
4794 final public void throw_expression() throws ParseException {
4795
4796 AstThrowExpression jjtn000 = new AstThrowExpression(JJTTHROWEXPRESSION);
4797 boolean jjtc000 = true;
4798 jjtree.openNodeScope(jjtn000);
4799 jjtreeOpenNodeScope(jjtn000);
4800 try {
4801 jj_consume_token(THROW);
4802 if (jj_2_74(2147483647)) {
4803 assignment_expression();
4804 } else {
4805 ;
4806 }
4807 } catch (Throwable jjte000) {
4808 if (jjtc000) {
4809 jjtree.clearNodeScope(jjtn000);
4810 jjtc000 = false;
4811 } else {
4812 jjtree.popNode();
4813 }
4814 if (jjte000 instanceof RuntimeException) {
4815 {if (true) throw (RuntimeException)jjte000;}
4816 }
4817 if (jjte000 instanceof ParseException) {
4818 {if (true) throw (ParseException)jjte000;}
4819 }
4820 {if (true) throw (Error)jjte000;}
4821 } finally {
4822 if (jjtc000) {
4823 jjtree.closeNodeScope(jjtn000, true);
4824 jjtreeCloseNodeScope(jjtn000);
4825 }
4826 }
4827 }
4828
4829 final public void expression() throws ParseException {
4830 assignment_expression();
4831 label_29:
4832 while (true) {
4833 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4834 case COMMA:
4835 ;
4836 break;
4837 default:
4838 jj_la1[127] = jj_gen;
4839 break label_29;
4840 }
4841 jj_consume_token(COMMA);
4842 assignment_expression();
4843 }
4844 }
4845
4846 final public void assignment_expression() throws ParseException {
4847
4848 AstAssignmentExpression jjtn000 = new AstAssignmentExpression(JJTASSIGNMENTEXPRESSION);
4849 boolean jjtc000 = true;
4850 jjtree.openNodeScope(jjtn000);
4851 jjtreeOpenNodeScope(jjtn000);
4852 try {
4853 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4854 case LPARENTHESIS:
4855 case SCOPE:
4856 case AMPERSAND:
4857 case PLUS:
4858 case MINUS:
4859 case STAR:
4860 case PLUSPLUS:
4861 case MINUSMINUS:
4862 case TILDE:
4863 case NOT:
4864 case BOOL:
4865 case CHAR:
4866 case DELETE:
4867 case DOUBLE:
4868 case FLOAT:
4869 case INT:
4870 case LONG:
4871 case NEW:
4872 case SHORT:
4873 case SIGNED:
4874 case SIZEOF:
4875 case TEMPLATE:
4876 case THIS:
4877 case TYPEID:
4878 case UNSIGNED:
4879 case VOID:
4880 case WCHAR_T:
4881 case OPERATOR:
4882 case TRUETOK:
4883 case FALSETOK:
4884 case OCTALINT:
4885 case OCTALLONG:
4886 case UNSIGNED_OCTALINT:
4887 case UNSIGNED_OCTALLONG:
4888 case DECIMALINT:
4889 case DECIMALLONG:
4890 case UNSIGNED_DECIMALINT:
4891 case UNSIGNED_DECIMALLONG:
4892 case HEXADECIMALINT:
4893 case HEXADECIMALLONG:
4894 case UNSIGNED_HEXADECIMALINT:
4895 case UNSIGNED_HEXADECIMALLONG:
4896 case FLOATONE:
4897 case FLOATTWO:
4898 case CHARACTER:
4899 case STRING:
4900 case ID:
4901 conditional_expression();
4902 if (jj_2_75(2)) {
4903 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4904 case ASSIGNEQUAL:
4905 jj_consume_token(ASSIGNEQUAL);
4906 break;
4907 case TIMESEQUAL:
4908 jj_consume_token(TIMESEQUAL);
4909 break;
4910 case DIVIDEEQUAL:
4911 jj_consume_token(DIVIDEEQUAL);
4912 break;
4913 case MODEQUAL:
4914 jj_consume_token(MODEQUAL);
4915 break;
4916 case PLUSEQUAL:
4917 jj_consume_token(PLUSEQUAL);
4918 break;
4919 case MINUSEQUAL:
4920 jj_consume_token(MINUSEQUAL);
4921 break;
4922 case SHIFTLEFTEQUAL:
4923 jj_consume_token(SHIFTLEFTEQUAL);
4924 break;
4925 case SHIFTRIGHTEQUAL:
4926 jj_consume_token(SHIFTRIGHTEQUAL);
4927 break;
4928 case BITWISEANDEQUAL:
4929 jj_consume_token(BITWISEANDEQUAL);
4930 break;
4931 case BITWISEXOREQUAL:
4932 jj_consume_token(BITWISEXOREQUAL);
4933 break;
4934 case BITWISEOREQUAL:
4935 jj_consume_token(BITWISEOREQUAL);
4936 break;
4937 default:
4938 jj_la1[128] = jj_gen;
4939 jj_consume_token(-1);
4940 throw new ParseException();
4941 }
4942 assignment_expression();
4943 } else {
4944 ;
4945 }
4946 break;
4947 case THROW:
4948 throw_expression();
4949 break;
4950 default:
4951 jj_la1[129] = jj_gen;
4952 jj_consume_token(-1);
4953 throw new ParseException();
4954 }
4955 } catch (Throwable jjte000) {
4956 if (jjtc000) {
4957 jjtree.clearNodeScope(jjtn000);
4958 jjtc000 = false;
4959 } else {
4960 jjtree.popNode();
4961 }
4962 if (jjte000 instanceof RuntimeException) {
4963 {if (true) throw (RuntimeException)jjte000;}
4964 }
4965 if (jjte000 instanceof ParseException) {
4966 {if (true) throw (ParseException)jjte000;}
4967 }
4968 {if (true) throw (Error)jjte000;}
4969 } finally {
4970 if (jjtc000) {
4971 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
4972 jjtreeCloseNodeScope(jjtn000);
4973 }
4974 }
4975 }
4976
4977 final public void constant_expression() throws ParseException {
4978 conditional_expression();
4979 }
4980
4981 final public void conditional_expression() throws ParseException {
4982
4983 AstConditionalExpression jjtn000 = new AstConditionalExpression(JJTCONDITIONALEXPRESSION);
4984 boolean jjtc000 = true;
4985 jjtree.openNodeScope(jjtn000);
4986 jjtreeOpenNodeScope(jjtn000);
4987 try {
4988 logical_or_expression();
4989 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4990 case QUESTIONMARK:
4991 jj_consume_token(QUESTIONMARK);
4992 assignment_expression();
4993 jj_consume_token(COLON);
4994 assignment_expression();
4995 break;
4996 default:
4997 jj_la1[130] = jj_gen;
4998 ;
4999 }
5000 } catch (Throwable jjte000) {
5001 if (jjtc000) {
5002 jjtree.clearNodeScope(jjtn000);
5003 jjtc000 = false;
5004 } else {
5005 jjtree.popNode();
5006 }
5007 if (jjte000 instanceof RuntimeException) {
5008 {if (true) throw (RuntimeException)jjte000;}
5009 }
5010 if (jjte000 instanceof ParseException) {
5011 {if (true) throw (ParseException)jjte000;}
5012 }
5013 {if (true) throw (Error)jjte000;}
5014 } finally {
5015 if (jjtc000) {
5016 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5017 jjtreeCloseNodeScope(jjtn000);
5018 }
5019 }
5020 }
5021
5022 final public void logical_or_expression() throws ParseException {
5023
5024 AstLogicalOrExpression jjtn000 = new AstLogicalOrExpression(JJTLOGICALOREXPRESSION);
5025 boolean jjtc000 = true;
5026 jjtree.openNodeScope(jjtn000);
5027 jjtreeOpenNodeScope(jjtn000);
5028 try {
5029 logical_and_expression();
5030 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5031 case OR:
5032 jj_consume_token(OR);
5033 logical_or_expression();
5034 break;
5035 default:
5036 jj_la1[131] = jj_gen;
5037 ;
5038 }
5039 } catch (Throwable jjte000) {
5040 if (jjtc000) {
5041 jjtree.clearNodeScope(jjtn000);
5042 jjtc000 = false;
5043 } else {
5044 jjtree.popNode();
5045 }
5046 if (jjte000 instanceof RuntimeException) {
5047 {if (true) throw (RuntimeException)jjte000;}
5048 }
5049 if (jjte000 instanceof ParseException) {
5050 {if (true) throw (ParseException)jjte000;}
5051 }
5052 {if (true) throw (Error)jjte000;}
5053 } finally {
5054 if (jjtc000) {
5055 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5056 jjtreeCloseNodeScope(jjtn000);
5057 }
5058 }
5059 }
5060
5061 final public void logical_and_expression() throws ParseException {
5062
5063 AstLogicalAndExpression jjtn000 = new AstLogicalAndExpression(JJTLOGICALANDEXPRESSION);
5064 boolean jjtc000 = true;
5065 jjtree.openNodeScope(jjtn000);
5066 jjtreeOpenNodeScope(jjtn000);
5067 try {
5068 inclusive_or_expression();
5069 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5070 case AND:
5071 jj_consume_token(AND);
5072 logical_and_expression();
5073 break;
5074 default:
5075 jj_la1[132] = jj_gen;
5076 ;
5077 }
5078 } catch (Throwable jjte000) {
5079 if (jjtc000) {
5080 jjtree.clearNodeScope(jjtn000);
5081 jjtc000 = false;
5082 } else {
5083 jjtree.popNode();
5084 }
5085 if (jjte000 instanceof RuntimeException) {
5086 {if (true) throw (RuntimeException)jjte000;}
5087 }
5088 if (jjte000 instanceof ParseException) {
5089 {if (true) throw (ParseException)jjte000;}
5090 }
5091 {if (true) throw (Error)jjte000;}
5092 } finally {
5093 if (jjtc000) {
5094 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5095 jjtreeCloseNodeScope(jjtn000);
5096 }
5097 }
5098 }
5099
5100 final public void inclusive_or_expression() throws ParseException {
5101
5102 AstInclusiveOrExpression jjtn000 = new AstInclusiveOrExpression(JJTINCLUSIVEOREXPRESSION);
5103 boolean jjtc000 = true;
5104 jjtree.openNodeScope(jjtn000);
5105 jjtreeOpenNodeScope(jjtn000);
5106 try {
5107 exclusive_or_expression();
5108 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5109 case BITWISEOR:
5110 jj_consume_token(BITWISEOR);
5111 inclusive_or_expression();
5112 break;
5113 default:
5114 jj_la1[133] = jj_gen;
5115 ;
5116 }
5117 } catch (Throwable jjte000) {
5118 if (jjtc000) {
5119 jjtree.clearNodeScope(jjtn000);
5120 jjtc000 = false;
5121 } else {
5122 jjtree.popNode();
5123 }
5124 if (jjte000 instanceof RuntimeException) {
5125 {if (true) throw (RuntimeException)jjte000;}
5126 }
5127 if (jjte000 instanceof ParseException) {
5128 {if (true) throw (ParseException)jjte000;}
5129 }
5130 {if (true) throw (Error)jjte000;}
5131 } finally {
5132 if (jjtc000) {
5133 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5134 jjtreeCloseNodeScope(jjtn000);
5135 }
5136 }
5137 }
5138
5139 final public void exclusive_or_expression() throws ParseException {
5140
5141 AstExclusiveOrExpression jjtn000 = new AstExclusiveOrExpression(JJTEXCLUSIVEOREXPRESSION);
5142 boolean jjtc000 = true;
5143 jjtree.openNodeScope(jjtn000);
5144 jjtreeOpenNodeScope(jjtn000);
5145 try {
5146 and_expression();
5147 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5148 case BITWISEXOR:
5149 jj_consume_token(BITWISEXOR);
5150 exclusive_or_expression();
5151 break;
5152 default:
5153 jj_la1[134] = jj_gen;
5154 ;
5155 }
5156 } catch (Throwable jjte000) {
5157 if (jjtc000) {
5158 jjtree.clearNodeScope(jjtn000);
5159 jjtc000 = false;
5160 } else {
5161 jjtree.popNode();
5162 }
5163 if (jjte000 instanceof RuntimeException) {
5164 {if (true) throw (RuntimeException)jjte000;}
5165 }
5166 if (jjte000 instanceof ParseException) {
5167 {if (true) throw (ParseException)jjte000;}
5168 }
5169 {if (true) throw (Error)jjte000;}
5170 } finally {
5171 if (jjtc000) {
5172 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5173 jjtreeCloseNodeScope(jjtn000);
5174 }
5175 }
5176 }
5177
5178 final public void and_expression() throws ParseException {
5179
5180 AstAndExpression jjtn000 = new AstAndExpression(JJTANDEXPRESSION);
5181 boolean jjtc000 = true;
5182 jjtree.openNodeScope(jjtn000);
5183 jjtreeOpenNodeScope(jjtn000);
5184 try {
5185 equality_expression();
5186 if (jj_2_76(2)) {
5187 jj_consume_token(AMPERSAND);
5188 and_expression();
5189 } else {
5190 ;
5191 }
5192 } catch (Throwable jjte000) {
5193 if (jjtc000) {
5194 jjtree.clearNodeScope(jjtn000);
5195 jjtc000 = false;
5196 } else {
5197 jjtree.popNode();
5198 }
5199 if (jjte000 instanceof RuntimeException) {
5200 {if (true) throw (RuntimeException)jjte000;}
5201 }
5202 if (jjte000 instanceof ParseException) {
5203 {if (true) throw (ParseException)jjte000;}
5204 }
5205 {if (true) throw (Error)jjte000;}
5206 } finally {
5207 if (jjtc000) {
5208 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5209 jjtreeCloseNodeScope(jjtn000);
5210 }
5211 }
5212 }
5213
5214 final public void equality_expression() throws ParseException {
5215
5216 AstEqualityExpression jjtn000 = new AstEqualityExpression(JJTEQUALITYEXPRESSION);
5217 boolean jjtc000 = true;
5218 jjtree.openNodeScope(jjtn000);
5219 jjtreeOpenNodeScope(jjtn000);
5220 try {
5221 relational_expression();
5222 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5223 case EQUAL:
5224 case NOTEQUAL:
5225 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5226 case NOTEQUAL:
5227 jj_consume_token(NOTEQUAL);
5228 break;
5229 case EQUAL:
5230 jj_consume_token(EQUAL);
5231 break;
5232 default:
5233 jj_la1[135] = jj_gen;
5234 jj_consume_token(-1);
5235 throw new ParseException();
5236 }
5237 equality_expression();
5238 break;
5239 default:
5240 jj_la1[136] = jj_gen;
5241 ;
5242 }
5243 } catch (Throwable jjte000) {
5244 if (jjtc000) {
5245 jjtree.clearNodeScope(jjtn000);
5246 jjtc000 = false;
5247 } else {
5248 jjtree.popNode();
5249 }
5250 if (jjte000 instanceof RuntimeException) {
5251 {if (true) throw (RuntimeException)jjte000;}
5252 }
5253 if (jjte000 instanceof ParseException) {
5254 {if (true) throw (ParseException)jjte000;}
5255 }
5256 {if (true) throw (Error)jjte000;}
5257 } finally {
5258 if (jjtc000) {
5259 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5260 jjtreeCloseNodeScope(jjtn000);
5261 }
5262 }
5263 }
5264
5265 final public void relational_expression() throws ParseException {
5266
5267 AstRelationalExpression jjtn000 = new AstRelationalExpression(JJTRELATIONALEXPRESSION);
5268 boolean jjtc000 = true;
5269 jjtree.openNodeScope(jjtn000);
5270 jjtreeOpenNodeScope(jjtn000);
5271 try {
5272 shift_expression();
5273 if (jj_2_77(2)) {
5274 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5275 case LESSTHAN:
5276 jj_consume_token(LESSTHAN);
5277 break;
5278 case GREATERTHAN:
5279 jj_consume_token(GREATERTHAN);
5280 break;
5281 case LESSTHANOREQUALTO:
5282 jj_consume_token(LESSTHANOREQUALTO);
5283 break;
5284 case GREATERTHANOREQUALTO:
5285 jj_consume_token(GREATERTHANOREQUALTO);
5286 break;
5287 default:
5288 jj_la1[137] = jj_gen;
5289 jj_consume_token(-1);
5290 throw new ParseException();
5291 }
5292 relational_expression();
5293 } else {
5294 ;
5295 }
5296 } catch (Throwable jjte000) {
5297 if (jjtc000) {
5298 jjtree.clearNodeScope(jjtn000);
5299 jjtc000 = false;
5300 } else {
5301 jjtree.popNode();
5302 }
5303 if (jjte000 instanceof RuntimeException) {
5304 {if (true) throw (RuntimeException)jjte000;}
5305 }
5306 if (jjte000 instanceof ParseException) {
5307 {if (true) throw (ParseException)jjte000;}
5308 }
5309 {if (true) throw (Error)jjte000;}
5310 } finally {
5311 if (jjtc000) {
5312 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5313 jjtreeCloseNodeScope(jjtn000);
5314 }
5315 }
5316 }
5317
5318 final public void shift_expression() throws ParseException {
5319
5320 AstShiftExpression jjtn000 = new AstShiftExpression(JJTSHIFTEXPRESSION);
5321 boolean jjtc000 = true;
5322 jjtree.openNodeScope(jjtn000);
5323 jjtreeOpenNodeScope(jjtn000);
5324 try {
5325 additive_expression();
5326 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5327 case SHIFTLEFT:
5328 case SHIFTRIGHT:
5329 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5330 case SHIFTLEFT:
5331 jj_consume_token(SHIFTLEFT);
5332 break;
5333 case SHIFTRIGHT:
5334 jj_consume_token(SHIFTRIGHT);
5335 break;
5336 default:
5337 jj_la1[138] = jj_gen;
5338 jj_consume_token(-1);
5339 throw new ParseException();
5340 }
5341 shift_expression();
5342 break;
5343 default:
5344 jj_la1[139] = jj_gen;
5345 ;
5346 }
5347 } catch (Throwable jjte000) {
5348 if (jjtc000) {
5349 jjtree.clearNodeScope(jjtn000);
5350 jjtc000 = false;
5351 } else {
5352 jjtree.popNode();
5353 }
5354 if (jjte000 instanceof RuntimeException) {
5355 {if (true) throw (RuntimeException)jjte000;}
5356 }
5357 if (jjte000 instanceof ParseException) {
5358 {if (true) throw (ParseException)jjte000;}
5359 }
5360 {if (true) throw (Error)jjte000;}
5361 } finally {
5362 if (jjtc000) {
5363 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5364 jjtreeCloseNodeScope(jjtn000);
5365 }
5366 }
5367 }
5368
5369 final public void additive_expression() throws ParseException {
5370
5371 AstAdditiveExpression jjtn000 = new AstAdditiveExpression(JJTADDITIVEEXPRESSION);
5372 boolean jjtc000 = true;
5373 jjtree.openNodeScope(jjtn000);
5374 jjtreeOpenNodeScope(jjtn000);
5375 try {
5376 multiplicative_expression();
5377 if (jj_2_78(2)) {
5378 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5379 case PLUS:
5380 jj_consume_token(PLUS);
5381 break;
5382 case MINUS:
5383 jj_consume_token(MINUS);
5384 break;
5385 default:
5386 jj_la1[140] = jj_gen;
5387 jj_consume_token(-1);
5388 throw new ParseException();
5389 }
5390 additive_expression();
5391 } else {
5392 ;
5393 }
5394 } catch (Throwable jjte000) {
5395 if (jjtc000) {
5396 jjtree.clearNodeScope(jjtn000);
5397 jjtc000 = false;
5398 } else {
5399 jjtree.popNode();
5400 }
5401 if (jjte000 instanceof RuntimeException) {
5402 {if (true) throw (RuntimeException)jjte000;}
5403 }
5404 if (jjte000 instanceof ParseException) {
5405 {if (true) throw (ParseException)jjte000;}
5406 }
5407 {if (true) throw (Error)jjte000;}
5408 } finally {
5409 if (jjtc000) {
5410 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5411 jjtreeCloseNodeScope(jjtn000);
5412 }
5413 }
5414 }
5415
5416 final public void multiplicative_expression() throws ParseException {
5417
5418 AstMultiplicativeExpression jjtn000 = new AstMultiplicativeExpression(JJTMULTIPLICATIVEEXPRESSION);
5419 boolean jjtc000 = true;
5420 jjtree.openNodeScope(jjtn000);
5421 jjtreeOpenNodeScope(jjtn000);
5422 try {
5423 pm_expression();
5424 if (jj_2_79(2)) {
5425 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5426 case STAR:
5427 jj_consume_token(STAR);
5428 break;
5429 case DIVIDE:
5430 jj_consume_token(DIVIDE);
5431 break;
5432 case MOD:
5433 jj_consume_token(MOD);
5434 break;
5435 default:
5436 jj_la1[141] = jj_gen;
5437 jj_consume_token(-1);
5438 throw new ParseException();
5439 }
5440 multiplicative_expression();
5441 } else {
5442 ;
5443 }
5444 } catch (Throwable jjte000) {
5445 if (jjtc000) {
5446 jjtree.clearNodeScope(jjtn000);
5447 jjtc000 = false;
5448 } else {
5449 jjtree.popNode();
5450 }
5451 if (jjte000 instanceof RuntimeException) {
5452 {if (true) throw (RuntimeException)jjte000;}
5453 }
5454 if (jjte000 instanceof ParseException) {
5455 {if (true) throw (ParseException)jjte000;}
5456 }
5457 {if (true) throw (Error)jjte000;}
5458 } finally {
5459 if (jjtc000) {
5460 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5461 jjtreeCloseNodeScope(jjtn000);
5462 }
5463 }
5464 }
5465
5466 final public void pm_expression() throws ParseException {
5467
5468 AstPointerToMemberExpression jjtn000 = new AstPointerToMemberExpression(JJTPOINTERTOMEMBEREXPRESSION);
5469 boolean jjtc000 = true;
5470 jjtree.openNodeScope(jjtn000);
5471 jjtreeOpenNodeScope(jjtn000);
5472 try {
5473 cast_expression();
5474 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5475 case DOTSTAR:
5476 case ARROWSTAR:
5477 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5478 case DOTSTAR:
5479 jj_consume_token(DOTSTAR);
5480 break;
5481 case ARROWSTAR:
5482 jj_consume_token(ARROWSTAR);
5483 break;
5484 default:
5485 jj_la1[142] = jj_gen;
5486 jj_consume_token(-1);
5487 throw new ParseException();
5488 }
5489 pm_expression();
5490 break;
5491 default:
5492 jj_la1[143] = jj_gen;
5493 ;
5494 }
5495 } catch (Throwable jjte000) {
5496 if (jjtc000) {
5497 jjtree.clearNodeScope(jjtn000);
5498 jjtc000 = false;
5499 } else {
5500 jjtree.popNode();
5501 }
5502 if (jjte000 instanceof RuntimeException) {
5503 {if (true) throw (RuntimeException)jjte000;}
5504 }
5505 if (jjte000 instanceof ParseException) {
5506 {if (true) throw (ParseException)jjte000;}
5507 }
5508 {if (true) throw (Error)jjte000;}
5509 } finally {
5510 if (jjtc000) {
5511 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
5512 jjtreeCloseNodeScope(jjtn000);
5513 }
5514 }
5515 }
5516
5517 final public void cast_expression() throws ParseException {
5518 if (jj_2_80(2147483647)) {
5519 AstCastExpression jjtn001 = new AstCastExpression(JJTCASTEXPRESSION);
5520 boolean jjtc001 = true;
5521 jjtree.openNodeScope(jjtn001);
5522 jjtreeOpenNodeScope(jjtn001);
5523 try {
5524 jj_consume_token(LPARENTHESIS);
5525 type_id();
5526 jj_consume_token(RPARENTHESIS);
5527 cast_expression();
5528 } catch (Throwable jjte001) {
5529 if (jjtc001) {
5530 jjtree.clearNodeScope(jjtn001);
5531 jjtc001 = false;
5532 } else {
5533 jjtree.popNode();
5534 }
5535 if (jjte001 instanceof RuntimeException) {
5536 {if (true) throw (RuntimeException)jjte001;}
5537 }
5538 if (jjte001 instanceof ParseException) {
5539 {if (true) throw (ParseException)jjte001;}
5540 }
5541 {if (true) throw (Error)jjte001;}
5542 } finally {
5543 if (jjtc001) {
5544 jjtree.closeNodeScope(jjtn001, true);
5545 jjtreeCloseNodeScope(jjtn001);
5546 }
5547 }
5548 } else if (jj_2_81(2147483647)) {
5549 AstCastExpression jjtn002 = new AstCastExpression(JJTCASTEXPRESSION);
5550 boolean jjtc002 = true;
5551 jjtree.openNodeScope(jjtn002);
5552 jjtreeOpenNodeScope(jjtn002);
5553 try {
5554 label_30:
5555 while (true) {
5556 builtin_type_specifier();
5557 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5558 case BOOL:
5559 case CHAR:
5560 case DOUBLE:
5561 case FLOAT:
5562 case INT:
5563 case LONG:
5564 case SHORT:
5565 case SIGNED:
5566 case UNSIGNED:
5567 case VOID:
5568 case WCHAR_T:
5569 ;
5570 break;
5571 default:
5572 jj_la1[144] = jj_gen;
5573 break label_30;
5574 }
5575 }
5576 jj_consume_token(LPARENTHESIS);
5577 assignment_expression();
5578 jj_consume_token(RPARENTHESIS);
5579 } catch (Throwable jjte002) {
5580 if (jjtc002) {
5581 jjtree.clearNodeScope(jjtn002);
5582 jjtc002 = false;
5583 } else {
5584 jjtree.popNode();
5585 }
5586 if (jjte002 instanceof RuntimeException) {
5587 {if (true) throw (RuntimeException)jjte002;}
5588 }
5589 if (jjte002 instanceof ParseException) {
5590 {if (true) throw (ParseException)jjte002;}
5591 }
5592 {if (true) throw (Error)jjte002;}
5593 } finally {
5594 if (jjtc002) {
5595 jjtree.closeNodeScope(jjtn002, true);
5596 jjtreeCloseNodeScope(jjtn002);
5597 }
5598 }
5599 } else {
5600 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5601 case LPARENTHESIS:
5602 case SCOPE:
5603 case AMPERSAND:
5604 case PLUS:
5605 case MINUS:
5606 case STAR:
5607 case PLUSPLUS:
5608 case MINUSMINUS:
5609 case TILDE:
5610 case NOT:
5611 case DELETE:
5612 case NEW:
5613 case SIZEOF:
5614 case TEMPLATE:
5615 case THIS:
5616 case TYPEID:
5617 case OPERATOR:
5618 case TRUETOK:
5619 case FALSETOK:
5620 case OCTALINT:
5621 case OCTALLONG:
5622 case UNSIGNED_OCTALINT:
5623 case UNSIGNED_OCTALLONG:
5624 case DECIMALINT:
5625 case DECIMALLONG:
5626 case UNSIGNED_DECIMALINT:
5627 case UNSIGNED_DECIMALLONG:
5628 case HEXADECIMALINT:
5629 case HEXADECIMALLONG:
5630 case UNSIGNED_HEXADECIMALINT:
5631 case UNSIGNED_HEXADECIMALLONG:
5632 case FLOATONE:
5633 case FLOATTWO:
5634 case CHARACTER:
5635 case STRING:
5636 case ID:
5637 unary_expression();
5638 break;
5639 default:
5640 jj_la1[145] = jj_gen;
5641 jj_consume_token(-1);
5642 throw new ParseException();
5643 }
5644 }
5645 }
5646
5647 final public void unary_expression() throws ParseException {
5648 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5649 case PLUSPLUS:
5650 AstUnaryExpression jjtn001 = new AstUnaryExpression(JJTUNARYEXPRESSION);
5651 boolean jjtc001 = true;
5652 jjtree.openNodeScope(jjtn001);
5653 jjtreeOpenNodeScope(jjtn001);
5654 try {
5655 jj_consume_token(PLUSPLUS);
5656 cast_expression();
5657 } catch (Throwable jjte001) {
5658 if (jjtc001) {
5659 jjtree.clearNodeScope(jjtn001);
5660 jjtc001 = false;
5661 } else {
5662 jjtree.popNode();
5663 }
5664 if (jjte001 instanceof RuntimeException) {
5665 {if (true) throw (RuntimeException)jjte001;}
5666 }
5667 if (jjte001 instanceof ParseException) {
5668 {if (true) throw (ParseException)jjte001;}
5669 }
5670 {if (true) throw (Error)jjte001;}
5671 } finally {
5672 if (jjtc001) {
5673 jjtree.closeNodeScope(jjtn001, true);
5674 jjtreeCloseNodeScope(jjtn001);
5675 }
5676 }
5677 break;
5678 case MINUSMINUS:
5679 AstUnaryExpression jjtn002 = new AstUnaryExpression(JJTUNARYEXPRESSION);
5680 boolean jjtc002 = true;
5681 jjtree.openNodeScope(jjtn002);
5682 jjtreeOpenNodeScope(jjtn002);
5683 try {
5684 jj_consume_token(MINUSMINUS);
5685 cast_expression();
5686 } catch (Throwable jjte002) {
5687 if (jjtc002) {
5688 jjtree.clearNodeScope(jjtn002);
5689 jjtc002 = false;
5690 } else {
5691 jjtree.popNode();
5692 }
5693 if (jjte002 instanceof RuntimeException) {
5694 {if (true) throw (RuntimeException)jjte002;}
5695 }
5696 if (jjte002 instanceof ParseException) {
5697 {if (true) throw (ParseException)jjte002;}
5698 }
5699 {if (true) throw (Error)jjte002;}
5700 } finally {
5701 if (jjtc002) {
5702 jjtree.closeNodeScope(jjtn002, true);
5703 jjtreeCloseNodeScope(jjtn002);
5704 }
5705 }
5706 break;
5707 default:
5708 jj_la1[147] = jj_gen;
5709 if (jj_2_83(3)) {
5710 AstUnaryExpression jjtn003 = new AstUnaryExpression(JJTUNARYEXPRESSION);
5711 boolean jjtc003 = true;
5712 jjtree.openNodeScope(jjtn003);
5713 jjtreeOpenNodeScope(jjtn003);
5714 try {
5715 unary_operator();
5716 cast_expression();
5717 } catch (Throwable jjte003) {
5718 if (jjtc003) {
5719 jjtree.clearNodeScope(jjtn003);
5720 jjtc003 = false;
5721 } else {
5722 jjtree.popNode();
5723 }
5724 if (jjte003 instanceof RuntimeException) {
5725 {if (true) throw (RuntimeException)jjte003;}
5726 }
5727 if (jjte003 instanceof ParseException) {
5728 {if (true) throw (ParseException)jjte003;}
5729 }
5730 {if (true) throw (Error)jjte003;}
5731 } finally {
5732 if (jjtc003) {
5733 jjtree.closeNodeScope(jjtn003, true);
5734 jjtreeCloseNodeScope(jjtn003);
5735 }
5736 }
5737 } else {
5738 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5739 case SIZEOF:
5740 AstUnaryExpression jjtn004 = new AstUnaryExpression(JJTUNARYEXPRESSION);
5741 boolean jjtc004 = true;
5742 jjtree.openNodeScope(jjtn004);
5743 jjtreeOpenNodeScope(jjtn004);
5744 try {
5745 jj_consume_token(SIZEOF);
5746 if (jj_2_82(2147483647)) {
5747 jj_consume_token(LPARENTHESIS);
5748 type_id();
5749 jj_consume_token(RPARENTHESIS);
5750 } else {
5751 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5752 case LPARENTHESIS:
5753 case SCOPE:
5754 case AMPERSAND:
5755 case PLUS:
5756 case MINUS:
5757 case STAR:
5758 case PLUSPLUS:
5759 case MINUSMINUS:
5760 case TILDE:
5761 case NOT:
5762 case DELETE:
5763 case NEW:
5764 case SIZEOF:
5765 case TEMPLATE:
5766 case THIS:
5767 case TYPEID:
5768 case OPERATOR:
5769 case TRUETOK:
5770 case FALSETOK:
5771 case OCTALINT:
5772 case OCTALLONG:
5773 case UNSIGNED_OCTALINT:
5774 case UNSIGNED_OCTALLONG:
5775 case DECIMALINT:
5776 case DECIMALLONG:
5777 case UNSIGNED_DECIMALINT:
5778 case UNSIGNED_DECIMALLONG:
5779 case HEXADECIMALINT:
5780 case HEXADECIMALLONG:
5781 case UNSIGNED_HEXADECIMALINT:
5782 case UNSIGNED_HEXADECIMALLONG:
5783 case FLOATONE:
5784 case FLOATTWO:
5785 case CHARACTER:
5786 case STRING:
5787 case ID:
5788 unary_expression();
5789 break;
5790 default:
5791 jj_la1[146] = jj_gen;
5792 jj_consume_token(-1);
5793 throw new ParseException();
5794 }
5795 }
5796 } catch (Throwable jjte004) {
5797 if (jjtc004) {
5798 jjtree.clearNodeScope(jjtn004);
5799 jjtc004 = false;
5800 } else {
5801 jjtree.popNode();
5802 }
5803 if (jjte004 instanceof RuntimeException) {
5804 {if (true) throw (RuntimeException)jjte004;}
5805 }
5806 if (jjte004 instanceof ParseException) {
5807 {if (true) throw (ParseException)jjte004;}
5808 }
5809 {if (true) throw (Error)jjte004;}
5810 } finally {
5811 if (jjtc004) {
5812 jjtree.closeNodeScope(jjtn004, true);
5813 jjtreeCloseNodeScope(jjtn004);
5814 }
5815 }
5816 break;
5817 case LPARENTHESIS:
5818 case SCOPE:
5819 case TILDE:
5820 case DELETE:
5821 case NEW:
5822 case TEMPLATE:
5823 case THIS:
5824 case TYPEID:
5825 case OPERATOR:
5826 case TRUETOK:
5827 case FALSETOK:
5828 case OCTALINT:
5829 case OCTALLONG:
5830 case UNSIGNED_OCTALINT:
5831 case UNSIGNED_OCTALLONG:
5832 case DECIMALINT:
5833 case DECIMALLONG:
5834 case UNSIGNED_DECIMALINT:
5835 case UNSIGNED_DECIMALLONG:
5836 case HEXADECIMALINT:
5837 case HEXADECIMALLONG:
5838 case UNSIGNED_HEXADECIMALINT:
5839 case UNSIGNED_HEXADECIMALLONG:
5840 case FLOATONE:
5841 case FLOATTWO:
5842 case CHARACTER:
5843 case STRING:
5844 case ID:
5845 postfix_expression();
5846 break;
5847 default:
5848 jj_la1[148] = jj_gen;
5849 jj_consume_token(-1);
5850 throw new ParseException();
5851 }
5852 }
5853 }
5854 }
5855
5856 final public void unary_operator() throws ParseException {
5857 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5858 case AMPERSAND:
5859 jj_consume_token(AMPERSAND);
5860 break;
5861 case STAR:
5862 jj_consume_token(STAR);
5863 break;
5864 case PLUS:
5865 jj_consume_token(PLUS);
5866 break;
5867 case MINUS:
5868 jj_consume_token(MINUS);
5869 break;
5870 case TILDE:
5871 jj_consume_token(TILDE);
5872 break;
5873 case NOT:
5874 jj_consume_token(NOT);
5875 break;
5876 default:
5877 jj_la1[149] = jj_gen;
5878 jj_consume_token(-1);
5879 throw new ParseException();
5880 }
5881 }
5882
5883 final public void postfix_expression() throws ParseException {
5884
5885 AstPostfixExpression jjtn000 = new AstPostfixExpression(JJTPOSTFIXEXPRESSION);
5886 boolean jjtc000 = true;
5887 jjtree.openNodeScope(jjtn000);
5888 jjtreeOpenNodeScope(jjtn000);
5889 try {
5890 if (jj_2_86(2147483647)) {
5891 primary_expression();
5892 label_31:
5893 while (true) {
5894 if (jj_2_84(2)) {
5895 ;
5896 } else {
5897 break label_31;
5898 }
5899 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5900 case LSQUAREBRACKET:
5901 jj_consume_token(LSQUAREBRACKET);
5902 expression();
5903 jj_consume_token(RSQUAREBRACKET);
5904 break;
5905 case LPARENTHESIS:
5906 jj_consume_token(LPARENTHESIS);
5907 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5908 case LPARENTHESIS:
5909 case SCOPE:
5910 case AMPERSAND:
5911 case PLUS:
5912 case MINUS:
5913 case STAR:
5914 case PLUSPLUS:
5915 case MINUSMINUS:
5916 case TILDE:
5917 case NOT:
5918 case BOOL:
5919 case CHAR:
5920 case DELETE:
5921 case DOUBLE:
5922 case FLOAT:
5923 case INT:
5924 case LONG:
5925 case NEW:
5926 case SHORT:
5927 case SIGNED:
5928 case SIZEOF:
5929 case TEMPLATE:
5930 case THIS:
5931 case TYPEID:
5932 case UNSIGNED:
5933 case VOID:
5934 case WCHAR_T:
5935 case OPERATOR:
5936 case TRUETOK:
5937 case FALSETOK:
5938 case THROW:
5939 case OCTALINT:
5940 case OCTALLONG:
5941 case UNSIGNED_OCTALINT:
5942 case UNSIGNED_OCTALLONG:
5943 case DECIMALINT:
5944 case DECIMALLONG:
5945 case UNSIGNED_DECIMALINT:
5946 case UNSIGNED_DECIMALLONG:
5947 case HEXADECIMALINT:
5948 case HEXADECIMALLONG:
5949 case UNSIGNED_HEXADECIMALINT:
5950 case UNSIGNED_HEXADECIMALLONG:
5951 case FLOATONE:
5952 case FLOATTWO:
5953 case CHARACTER:
5954 case STRING:
5955 case ID:
5956 expression_list();
5957 break;
5958 default:
5959 jj_la1[150] = jj_gen;
5960 ;
5961 }
5962 jj_consume_token(RPARENTHESIS);
5963 break;
5964 case DOT:
5965 case POINTERTO:
5966 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5967 case DOT:
5968 jj_consume_token(DOT);
5969 break;
5970 case POINTERTO:
5971 jj_consume_token(POINTERTO);
5972 break;
5973 default:
5974 jj_la1[151] = jj_gen;
5975 jj_consume_token(-1);
5976 throw new ParseException();
5977 }
5978 if (jj_2_85(2147483647)) {
5979 jj_consume_token(TEMPLATE);
5980 } else {
5981 ;
5982 }
5983 id_expression();
5984 break;
5985 case PLUSPLUS:
5986 AstPostfixExpression jjtn001 = new AstPostfixExpression(JJTPOSTFIXEXPRESSION);
5987 boolean jjtc001 = true;
5988 jjtree.openNodeScope(jjtn001);
5989 jjtreeOpenNodeScope(jjtn001);
5990 try {
5991 jj_consume_token(PLUSPLUS);
5992 } finally {
5993 if (jjtc001) {
5994 jjtree.closeNodeScope(jjtn001, true);
5995 jjtreeCloseNodeScope(jjtn001);
5996 }
5997 }
5998 break;
5999 case MINUSMINUS:
6000 AstPostfixExpression jjtn002 = new AstPostfixExpression(JJTPOSTFIXEXPRESSION);
6001 boolean jjtc002 = true;
6002 jjtree.openNodeScope(jjtn002);
6003 jjtreeOpenNodeScope(jjtn002);
6004 try {
6005 jj_consume_token(MINUSMINUS);
6006 } finally {
6007 if (jjtc002) {
6008 jjtree.closeNodeScope(jjtn002, true);
6009 jjtreeCloseNodeScope(jjtn002);
6010 }
6011 }
6012 break;
6013 default:
6014 jj_la1[152] = jj_gen;
6015 jj_consume_token(-1);
6016 throw new ParseException();
6017 }
6018 }
6019 } else {
6020 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6021 case SCOPE:
6022 case TEMPLATE:
6023 case ID:
6024 AstFunctionCallExpression jjtn003 = new AstFunctionCallExpression(JJTFUNCTIONCALLEXPRESSION);
6025 boolean jjtc003 = true;
6026 jjtree.openNodeScope(jjtn003);
6027 jjtreeOpenNodeScope(jjtn003);
6028 try {
6029 qualified_type();
6030 jj_consume_token(LPARENTHESIS);
6031 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6032 case LPARENTHESIS:
6033 case SCOPE:
6034 case AMPERSAND:
6035 case PLUS:
6036 case MINUS:
6037 case STAR:
6038 case PLUSPLUS:
6039 case MINUSMINUS:
6040 case TILDE:
6041 case NOT:
6042 case BOOL:
6043 case CHAR:
6044 case DELETE:
6045 case DOUBLE:
6046 case FLOAT:
6047 case INT:
6048 case LONG:
6049 case NEW:
6050 case SHORT:
6051 case SIGNED:
6052 case SIZEOF:
6053 case TEMPLATE:
6054 case THIS:
6055 case TYPEID:
6056 case UNSIGNED:
6057 case VOID:
6058 case WCHAR_T:
6059 case OPERATOR:
6060 case TRUETOK:
6061 case FALSETOK:
6062 case THROW:
6063 case OCTALINT:
6064 case OCTALLONG:
6065 case UNSIGNED_OCTALINT:
6066 case UNSIGNED_OCTALLONG:
6067 case DECIMALINT:
6068 case DECIMALLONG:
6069 case UNSIGNED_DECIMALINT:
6070 case UNSIGNED_DECIMALLONG:
6071 case HEXADECIMALINT:
6072 case HEXADECIMALLONG:
6073 case UNSIGNED_HEXADECIMALINT:
6074 case UNSIGNED_HEXADECIMALLONG:
6075 case FLOATONE:
6076 case FLOATTWO:
6077 case CHARACTER:
6078 case STRING:
6079 case ID:
6080 expression_list();
6081 break;
6082 default:
6083 jj_la1[153] = jj_gen;
6084 ;
6085 }
6086 jj_consume_token(RPARENTHESIS);
6087 } catch (Throwable jjte003) {
6088 if (jjtc003) {
6089 jjtree.clearNodeScope(jjtn003);
6090 jjtc003 = false;
6091 } else {
6092 jjtree.popNode();
6093 }
6094 if (jjte003 instanceof RuntimeException) {
6095 {if (true) throw (RuntimeException)jjte003;}
6096 }
6097 if (jjte003 instanceof ParseException) {
6098 {if (true) throw (ParseException)jjte003;}
6099 }
6100 {if (true) throw (Error)jjte003;}
6101 } finally {
6102 if (jjtc003) {
6103 jjtree.closeNodeScope(jjtn003, true);
6104 jjtreeCloseNodeScope(jjtn003);
6105 }
6106 }
6107 break;
6108 default:
6109 jj_la1[154] = jj_gen;
6110 jj_consume_token(-1);
6111 throw new ParseException();
6112 }
6113 }
6114 } catch (Throwable jjte000) {
6115 if (jjtc000) {
6116 jjtree.clearNodeScope(jjtn000);
6117 jjtc000 = false;
6118 } else {
6119 jjtree.popNode();
6120 }
6121 if (jjte000 instanceof RuntimeException) {
6122 {if (true) throw (RuntimeException)jjte000;}
6123 }
6124 if (jjte000 instanceof ParseException) {
6125 {if (true) throw (ParseException)jjte000;}
6126 }
6127 {if (true) throw (Error)jjte000;}
6128 } finally {
6129 if (jjtc000) {
6130 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
6131 jjtreeCloseNodeScope(jjtn000);
6132 }
6133 }
6134 }
6135
6136 final public void id_expression() throws ParseException {
6137
6138 AstIdExpression jjtn000 = new AstIdExpression(JJTIDEXPRESSION);
6139 boolean jjtc000 = true;
6140 jjtree.openNodeScope(jjtn000);
6141 jjtreeOpenNodeScope(jjtn000);
6142 try {
6143 if (jj_2_87(2147483647)) {
6144 scope_override();
6145 } else {
6146 ;
6147 }
6148 unqualified_id();
6149 } catch (Throwable jjte000) {
6150 if (jjtc000) {
6151 jjtree.clearNodeScope(jjtn000);
6152 jjtc000 = false;
6153 } else {
6154 jjtree.popNode();
6155 }
6156 if (jjte000 instanceof RuntimeException) {
6157 {if (true) throw (RuntimeException)jjte000;}
6158 }
6159 if (jjte000 instanceof ParseException) {
6160 {if (true) throw (ParseException)jjte000;}
6161 }
6162 {if (true) throw (Error)jjte000;}
6163 } finally {
6164 if (jjtc000) {
6165 jjtree.closeNodeScope(jjtn000, true);
6166 jjtreeCloseNodeScope(jjtn000);
6167 }
6168 }
6169 }
6170
6171 final public void unqualified_id() throws ParseException {
6172 if (jj_2_88(2147483647)) {
6173 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6174 case TILDE:
6175 jj_consume_token(TILDE);
6176 break;
6177 default:
6178 jj_la1[155] = jj_gen;
6179 ;
6180 }
6181 template_id();
6182 } else if (jj_2_89(2147483647)) {
6183 operator_function_id();
6184 } else {
6185 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6186 case OPERATOR:
6187 conversion_function_id();
6188 break;
6189 case TILDE:
6190 case ID:
6191 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6192 case TILDE:
6193 jj_consume_token(TILDE);
6194 break;
6195 default:
6196 jj_la1[156] = jj_gen;
6197 ;
6198 }
6199 jj_consume_token(ID);
6200 break;
6201 default:
6202 jj_la1[157] = jj_gen;
6203 jj_consume_token(-1);
6204 throw new ParseException();
6205 }
6206 }
6207 }
6208
6209 final public void operator_function_id() throws ParseException {
6210 jj_consume_token(OPERATOR);
6211 operator();
6212 if (jj_2_90(2147483647)) {
6213 template_argument_list();
6214 } else {
6215 ;
6216 }
6217 }
6218
6219 final public void conversion_function_id() throws ParseException {
6220 jj_consume_token(OPERATOR);
6221 declaration_specifiers();
6222 if (jj_2_91(2147483647)) {
6223 ptr_operator_seq();
6224 } else {
6225 ;
6226 }
6227 }
6228
6229 final public void template_id() throws ParseException {
6230 jj_consume_token(ID);
6231 template_argument_list();
6232 }
6233
6234 final public void primary_expression() throws ParseException {
6235 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6236 case THIS:
6237 AstPrimaryExpression jjtn001 = new AstPrimaryExpression(JJTPRIMARYEXPRESSION);
6238 boolean jjtc001 = true;
6239 jjtree.openNodeScope(jjtn001);
6240 jjtreeOpenNodeScope(jjtn001);
6241 try {
6242 jj_consume_token(THIS);
6243 } finally {
6244 if (jjtc001) {
6245 jjtree.closeNodeScope(jjtn001, true);
6246 jjtreeCloseNodeScope(jjtn001);
6247 }
6248 }
6249 break;
6250 case STRING:
6251 AstConstantExpression jjtn002 = new AstConstantExpression(JJTCONSTANTEXPRESSION);
6252 boolean jjtc002 = true;
6253 jjtree.openNodeScope(jjtn002);
6254 jjtreeOpenNodeScope(jjtn002);
6255 try {
6256 label_32:
6257 while (true) {
6258 jj_consume_token(STRING);
6259 if (jj_2_92(2)) {
6260 ;
6261 } else {
6262 break label_32;
6263 }
6264 }
6265 } finally {
6266 if (jjtc002) {
6267 jjtree.closeNodeScope(jjtn002, true);
6268 jjtreeCloseNodeScope(jjtn002);
6269 }
6270 }
6271 break;
6272 case LPARENTHESIS:
6273 AstPrimaryExpression jjtn003 = new AstPrimaryExpression(JJTPRIMARYEXPRESSION);
6274 boolean jjtc003 = true;
6275 jjtree.openNodeScope(jjtn003);
6276 jjtreeOpenNodeScope(jjtn003);
6277 try {
6278 jj_consume_token(LPARENTHESIS);
6279 expression();
6280 jj_consume_token(RPARENTHESIS);
6281 } catch (Throwable jjte003) {
6282 if (jjtc003) {
6283 jjtree.clearNodeScope(jjtn003);
6284 jjtc003 = false;
6285 } else {
6286 jjtree.popNode();
6287 }
6288 if (jjte003 instanceof RuntimeException) {
6289 {if (true) throw (RuntimeException)jjte003;}
6290 }
6291 if (jjte003 instanceof ParseException) {
6292 {if (true) throw (ParseException)jjte003;}
6293 }
6294 {if (true) throw (Error)jjte003;}
6295 } finally {
6296 if (jjtc003) {
6297 jjtree.closeNodeScope(jjtn003, true);
6298 jjtreeCloseNodeScope(jjtn003);
6299 }
6300 }
6301 break;
6302 default:
6303 jj_la1[159] = jj_gen;
6304 if (jj_2_94(2147483647)) {
6305 new_expression();
6306 } else if (jj_2_95(2147483647)) {
6307 delete_expression();
6308 } else {
6309 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6310 case TYPEID:
6311 AstTypeIdExpression jjtn004 = new AstTypeIdExpression(JJTTYPEIDEXPRESSION);
6312 boolean jjtc004 = true;
6313 jjtree.openNodeScope(jjtn004);
6314 jjtreeOpenNodeScope(jjtn004);
6315 try {
6316 jj_consume_token(TYPEID);
6317 jj_consume_token(LPARENTHESIS);
6318 if (jj_2_93(2147483647)) {
6319 type_id();
6320 jj_consume_token(RPARENTHESIS);
6321 } else {
6322 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6323 case LPARENTHESIS:
6324 case SCOPE:
6325 case AMPERSAND:
6326 case PLUS:
6327 case MINUS:
6328 case STAR:
6329 case PLUSPLUS:
6330 case MINUSMINUS:
6331 case TILDE:
6332 case NOT:
6333 case BOOL:
6334 case CHAR:
6335 case DELETE:
6336 case DOUBLE:
6337 case FLOAT:
6338 case INT:
6339 case LONG:
6340 case NEW:
6341 case SHORT:
6342 case SIGNED:
6343 case SIZEOF:
6344 case TEMPLATE:
6345 case THIS:
6346 case TYPEID:
6347 case UNSIGNED:
6348 case VOID:
6349 case WCHAR_T:
6350 case OPERATOR:
6351 case TRUETOK:
6352 case FALSETOK:
6353 case THROW:
6354 case OCTALINT:
6355 case OCTALLONG:
6356 case UNSIGNED_OCTALINT:
6357 case UNSIGNED_OCTALLONG:
6358 case DECIMALINT:
6359 case DECIMALLONG:
6360 case UNSIGNED_DECIMALINT:
6361 case UNSIGNED_DECIMALLONG:
6362 case HEXADECIMALINT:
6363 case HEXADECIMALLONG:
6364 case UNSIGNED_HEXADECIMALINT:
6365 case UNSIGNED_HEXADECIMALLONG:
6366 case FLOATONE:
6367 case FLOATTWO:
6368 case CHARACTER:
6369 case STRING:
6370 case ID:
6371 expression();
6372 jj_consume_token(RPARENTHESIS);
6373 break;
6374 default:
6375 jj_la1[158] = jj_gen;
6376 jj_consume_token(-1);
6377 throw new ParseException();
6378 }
6379 }
6380 } catch (Throwable jjte004) {
6381 if (jjtc004) {
6382 jjtree.clearNodeScope(jjtn004);
6383 jjtc004 = false;
6384 } else {
6385 jjtree.popNode();
6386 }
6387 if (jjte004 instanceof RuntimeException) {
6388 {if (true) throw (RuntimeException)jjte004;}
6389 }
6390 if (jjte004 instanceof ParseException) {
6391 {if (true) throw (ParseException)jjte004;}
6392 }
6393 {if (true) throw (Error)jjte004;}
6394 } finally {
6395 if (jjtc004) {
6396 jjtree.closeNodeScope(jjtn004, true);
6397 jjtreeCloseNodeScope(jjtn004);
6398 }
6399 }
6400 break;
6401 case SCOPE:
6402 case TILDE:
6403 case TEMPLATE:
6404 case OPERATOR:
6405 case ID:
6406 id_expression();
6407 break;
6408 case TRUETOK:
6409 case FALSETOK:
6410 case OCTALINT:
6411 case OCTALLONG:
6412 case UNSIGNED_OCTALINT:
6413 case UNSIGNED_OCTALLONG:
6414 case DECIMALINT:
6415 case DECIMALLONG:
6416 case UNSIGNED_DECIMALINT:
6417 case UNSIGNED_DECIMALLONG:
6418 case HEXADECIMALINT:
6419 case HEXADECIMALLONG:
6420 case UNSIGNED_HEXADECIMALINT:
6421 case UNSIGNED_HEXADECIMALLONG:
6422 case FLOATONE:
6423 case FLOATTWO:
6424 case CHARACTER:
6425 AstConstantExpression jjtn005 = new AstConstantExpression(JJTCONSTANTEXPRESSION);
6426 boolean jjtc005 = true;
6427 jjtree.openNodeScope(jjtn005);
6428 jjtreeOpenNodeScope(jjtn005);
6429 try {
6430 constant();
6431 } catch (Throwable jjte005) {
6432 if (jjtc005) {
6433 jjtree.clearNodeScope(jjtn005);
6434 jjtc005 = false;
6435 } else {
6436 jjtree.popNode();
6437 }
6438 if (jjte005 instanceof RuntimeException) {
6439 {if (true) throw (RuntimeException)jjte005;}
6440 }
6441 if (jjte005 instanceof ParseException) {
6442 {if (true) throw (ParseException)jjte005;}
6443 }
6444 {if (true) throw (Error)jjte005;}
6445 } finally {
6446 if (jjtc005) {
6447 jjtree.closeNodeScope(jjtn005, true);
6448 jjtreeCloseNodeScope(jjtn005);
6449 }
6450 }
6451 break;
6452 default:
6453 jj_la1[160] = jj_gen;
6454 jj_consume_token(-1);
6455 throw new ParseException();
6456 }
6457 }
6458 }
6459 }
6460
6461 final public void new_expression() throws ParseException {
6462
6463 AstNewExpression jjtn000 = new AstNewExpression(JJTNEWEXPRESSION);
6464 boolean jjtc000 = true;
6465 jjtree.openNodeScope(jjtn000);
6466 jjtreeOpenNodeScope(jjtn000);
6467 try {
6468 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6469 case SCOPE:
6470 jj_consume_token(SCOPE);
6471 break;
6472 default:
6473 jj_la1[161] = jj_gen;
6474 ;
6475 }
6476 jj_consume_token(NEW);
6477 if (jj_2_96(2147483647)) {
6478 new_placement();
6479 } else {
6480 ;
6481 }
6482 if (jj_2_97(2147483647)) {
6483 jj_consume_token(LPARENTHESIS);
6484 type_id();
6485 jj_consume_token(RPARENTHESIS);
6486 } else {
6487 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6488 case SCOPE:
6489 case AUTO:
6490 case BOOL:
6491 case CHAR:
6492 case CONST:
6493 case DOUBLE:
6494 case ENUM:
6495 case EXTERN:
6496 case FLOAT:
6497 case FRIEND:
6498 case INLINE:
6499 case INT:
6500 case LONG:
6501 case MUTABLE:
6502 case REGISTER:
6503 case SHORT:
6504 case SIGNED:
6505 case STATIC:
6506 case STRUCT:
6507 case CLASS:
6508 case TEMPLATE:
6509 case TYPEDEF:
6510 case TYPENAME:
6511 case UNION:
6512 case UNSIGNED:
6513 case VIRTUAL:
6514 case VOID:
6515 case VOLATILE:
6516 case WCHAR_T:
6517 case ID:
6518 new_type_id();
6519 break;
6520 default:
6521 jj_la1[162] = jj_gen;
6522 jj_consume_token(-1);
6523 throw new ParseException();
6524 }
6525 }
6526 if (jj_2_98(2147483647)) {
6527 new_initializer();
6528 } else {
6529 ;
6530 }
6531 } catch (Throwable jjte000) {
6532 if (jjtc000) {
6533 jjtree.clearNodeScope(jjtn000);
6534 jjtc000 = false;
6535 } else {
6536 jjtree.popNode();
6537 }
6538 if (jjte000 instanceof RuntimeException) {
6539 {if (true) throw (RuntimeException)jjte000;}
6540 }
6541 if (jjte000 instanceof ParseException) {
6542 {if (true) throw (ParseException)jjte000;}
6543 }
6544 {if (true) throw (Error)jjte000;}
6545 } finally {
6546 if (jjtc000) {
6547 jjtree.closeNodeScope(jjtn000, true);
6548 jjtreeCloseNodeScope(jjtn000);
6549 }
6550 }
6551 }
6552
6553 final public void new_placement() throws ParseException {
6554 jj_consume_token(LPARENTHESIS);
6555 expression_list();
6556 jj_consume_token(RPARENTHESIS);
6557 }
6558
6559 final public void new_type_id() throws ParseException {
6560 declaration_specifiers();
6561 if (jj_2_99(2147483647)) {
6562 new_declarator();
6563 } else {
6564 ;
6565 }
6566 }
6567
6568 final public void new_declarator() throws ParseException {
6569 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6570 case LSQUAREBRACKET:
6571 direct_new_declarator();
6572 break;
6573 case SCOPE:
6574 case AMPERSAND:
6575 case STAR:
6576 case TEMPLATE:
6577 case ID:
6578 ptr_operator();
6579 cv_qualifier_seq();
6580 if (jj_2_100(2)) {
6581 new_declarator();
6582 } else {
6583 ;
6584 }
6585 break;
6586 default:
6587 jj_la1[163] = jj_gen;
6588 jj_consume_token(-1);
6589 throw new ParseException();
6590 }
6591 }
6592
6593 final public void direct_new_declarator() throws ParseException {
6594 label_33:
6595 while (true) {
6596 jj_consume_token(LSQUAREBRACKET);
6597 expression();
6598 jj_consume_token(RSQUAREBRACKET);
6599 if (jj_2_101(2147483647)) {
6600 ;
6601 } else {
6602 break label_33;
6603 }
6604 }
6605 }
6606
6607 final public void new_initializer() throws ParseException {
6608 jj_consume_token(LPARENTHESIS);
6609 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6610 case LPARENTHESIS:
6611 case SCOPE:
6612 case AMPERSAND:
6613 case PLUS:
6614 case MINUS:
6615 case STAR:
6616 case PLUSPLUS:
6617 case MINUSMINUS:
6618 case TILDE:
6619 case NOT:
6620 case BOOL:
6621 case CHAR:
6622 case DELETE:
6623 case DOUBLE:
6624 case FLOAT:
6625 case INT:
6626 case LONG:
6627 case NEW:
6628 case SHORT:
6629 case SIGNED:
6630 case SIZEOF:
6631 case TEMPLATE:
6632 case THIS:
6633 case TYPEID:
6634 case UNSIGNED:
6635 case VOID:
6636 case WCHAR_T:
6637 case OPERATOR:
6638 case TRUETOK:
6639 case FALSETOK:
6640 case THROW:
6641 case OCTALINT:
6642 case OCTALLONG:
6643 case UNSIGNED_OCTALINT:
6644 case UNSIGNED_OCTALLONG:
6645 case DECIMALINT:
6646 case DECIMALLONG:
6647 case UNSIGNED_DECIMALINT:
6648 case UNSIGNED_DECIMALLONG:
6649 case HEXADECIMALINT:
6650 case HEXADECIMALLONG:
6651 case UNSIGNED_HEXADECIMALINT:
6652 case UNSIGNED_HEXADECIMALLONG:
6653 case FLOATONE:
6654 case FLOATTWO:
6655 case CHARACTER:
6656 case STRING:
6657 case ID:
6658 expression_list();
6659 break;
6660 default:
6661 jj_la1[164] = jj_gen;
6662 ;
6663 }
6664 jj_consume_token(RPARENTHESIS);
6665 }
6666
6667 final public void delete_expression() throws ParseException {
6668
6669 AstDeleteExpression jjtn000 = new AstDeleteExpression(JJTDELETEEXPRESSION);
6670 boolean jjtc000 = true;
6671 jjtree.openNodeScope(jjtn000);
6672 jjtreeOpenNodeScope(jjtn000);
6673 try {
6674 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6675 case SCOPE:
6676 jj_consume_token(SCOPE);
6677 break;
6678 default:
6679 jj_la1[165] = jj_gen;
6680 ;
6681 }
6682 jj_consume_token(DELETE);
6683 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6684 case LSQUAREBRACKET:
6685 jj_consume_token(LSQUAREBRACKET);
6686 jj_consume_token(RSQUAREBRACKET);
6687 break;
6688 default:
6689 jj_la1[166] = jj_gen;
6690 ;
6691 }
6692 cast_expression();
6693 } catch (Throwable jjte000) {
6694 if (jjtc000) {
6695 jjtree.clearNodeScope(jjtn000);
6696 jjtc000 = false;
6697 } else {
6698 jjtree.popNode();
6699 }
6700 if (jjte000 instanceof RuntimeException) {
6701 {if (true) throw (RuntimeException)jjte000;}
6702 }
6703 if (jjte000 instanceof ParseException) {
6704 {if (true) throw (ParseException)jjte000;}
6705 }
6706 {if (true) throw (Error)jjte000;}
6707 } finally {
6708 if (jjtc000) {
6709 jjtree.closeNodeScope(jjtn000, true);
6710 jjtreeCloseNodeScope(jjtn000);
6711 }
6712 }
6713 }
6714
6715 final public void expression_list() throws ParseException {
6716 assignment_expression();
6717 label_34:
6718 while (true) {
6719 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6720 case COMMA:
6721 ;
6722 break;
6723 default:
6724 jj_la1[167] = jj_gen;
6725 break label_34;
6726 }
6727 jj_consume_token(COMMA);
6728 assignment_expression();
6729 }
6730 }
6731
6732 final public void constant() throws ParseException {
6733 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6734 case OCTALINT:
6735 jj_consume_token(OCTALINT);
6736 break;
6737 case OCTALLONG:
6738 jj_consume_token(OCTALLONG);
6739 break;
6740 case DECIMALINT:
6741 jj_consume_token(DECIMALINT);
6742 break;
6743 case DECIMALLONG:
6744 jj_consume_token(DECIMALLONG);
6745 break;
6746 case HEXADECIMALINT:
6747 jj_consume_token(HEXADECIMALINT);
6748 break;
6749 case HEXADECIMALLONG:
6750 jj_consume_token(HEXADECIMALLONG);
6751 break;
6752 case UNSIGNED_OCTALINT:
6753 jj_consume_token(UNSIGNED_OCTALINT);
6754 break;
6755 case UNSIGNED_OCTALLONG:
6756 jj_consume_token(UNSIGNED_OCTALLONG);
6757 break;
6758 case UNSIGNED_DECIMALINT:
6759 jj_consume_token(UNSIGNED_DECIMALINT);
6760 break;
6761 case UNSIGNED_DECIMALLONG:
6762 jj_consume_token(UNSIGNED_DECIMALLONG);
6763 break;
6764 case UNSIGNED_HEXADECIMALINT:
6765 jj_consume_token(UNSIGNED_HEXADECIMALINT);
6766 break;
6767 case UNSIGNED_HEXADECIMALLONG:
6768 jj_consume_token(UNSIGNED_HEXADECIMALLONG);
6769 break;
6770 case CHARACTER:
6771 jj_consume_token(CHARACTER);
6772 break;
6773 case FLOATONE:
6774 jj_consume_token(FLOATONE);
6775 break;
6776 case FLOATTWO:
6777 jj_consume_token(FLOATTWO);
6778 break;
6779 case TRUETOK:
6780 jj_consume_token(TRUETOK);
6781 break;
6782 case FALSETOK:
6783 jj_consume_token(FALSETOK);
6784 break;
6785 default:
6786 jj_la1[168] = jj_gen;
6787 jj_consume_token(-1);
6788 throw new ParseException();
6789 }
6790 }
6791
6792 final public void operator() throws ParseException {
6793 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6794 case NEW:
6795 jj_consume_token(NEW);
6796 if (jj_2_102(2)) {
6797 jj_consume_token(LSQUAREBRACKET);
6798 jj_consume_token(RSQUAREBRACKET);
6799 } else {
6800 ;
6801 }
6802 break;
6803 case DELETE:
6804 jj_consume_token(DELETE);
6805 if (jj_2_103(2)) {
6806 jj_consume_token(LSQUAREBRACKET);
6807 jj_consume_token(RSQUAREBRACKET);
6808 } else {
6809 ;
6810 }
6811 break;
6812 case PLUS:
6813 jj_consume_token(PLUS);
6814 break;
6815 case MINUS:
6816 jj_consume_token(MINUS);
6817 break;
6818 case STAR:
6819 jj_consume_token(STAR);
6820 break;
6821 case DIVIDE:
6822 jj_consume_token(DIVIDE);
6823 break;
6824 case MOD:
6825 jj_consume_token(MOD);
6826 break;
6827 case BITWISEXOR:
6828 jj_consume_token(BITWISEXOR);
6829 break;
6830 case AMPERSAND:
6831 jj_consume_token(AMPERSAND);
6832 break;
6833 case BITWISEOR:
6834 jj_consume_token(BITWISEOR);
6835 break;
6836 case TILDE:
6837 jj_consume_token(TILDE);
6838 break;
6839 case NOT:
6840 jj_consume_token(NOT);
6841 break;
6842 case ASSIGNEQUAL:
6843 jj_consume_token(ASSIGNEQUAL);
6844 break;
6845 case LESSTHAN:
6846 jj_consume_token(LESSTHAN);
6847 break;
6848 case GREATERTHAN:
6849 jj_consume_token(GREATERTHAN);
6850 break;
6851 case PLUSEQUAL:
6852 jj_consume_token(PLUSEQUAL);
6853 break;
6854 case MINUSEQUAL:
6855 jj_consume_token(MINUSEQUAL);
6856 break;
6857 case TIMESEQUAL:
6858 jj_consume_token(TIMESEQUAL);
6859 break;
6860 case DIVIDEEQUAL:
6861 jj_consume_token(DIVIDEEQUAL);
6862 break;
6863 case MODEQUAL:
6864 jj_consume_token(MODEQUAL);
6865 break;
6866 case BITWISEXOREQUAL:
6867 jj_consume_token(BITWISEXOREQUAL);
6868 break;
6869 case BITWISEANDEQUAL:
6870 jj_consume_token(BITWISEANDEQUAL);
6871 break;
6872 case BITWISEOREQUAL:
6873 jj_consume_token(BITWISEOREQUAL);
6874 break;
6875 case SHIFTLEFT:
6876 jj_consume_token(SHIFTLEFT);
6877 break;
6878 case SHIFTRIGHT:
6879 jj_consume_token(SHIFTRIGHT);
6880 break;
6881 case SHIFTRIGHTEQUAL:
6882 jj_consume_token(SHIFTRIGHTEQUAL);
6883 break;
6884 case SHIFTLEFTEQUAL:
6885 jj_consume_token(SHIFTLEFTEQUAL);
6886 break;
6887 case EQUAL:
6888 jj_consume_token(EQUAL);
6889 break;
6890 case NOTEQUAL:
6891 jj_consume_token(NOTEQUAL);
6892 break;
6893 case LESSTHANOREQUALTO:
6894 jj_consume_token(LESSTHANOREQUALTO);
6895 break;
6896 case GREATERTHANOREQUALTO:
6897 jj_consume_token(GREATERTHANOREQUALTO);
6898 break;
6899 case AND:
6900 jj_consume_token(AND);
6901 break;
6902 case OR:
6903 jj_consume_token(OR);
6904 break;
6905 case PLUSPLUS:
6906 jj_consume_token(PLUSPLUS);
6907 break;
6908 case MINUSMINUS:
6909 jj_consume_token(MINUSMINUS);
6910 break;
6911 case COMMA:
6912 jj_consume_token(COMMA);
6913 break;
6914 case ARROWSTAR:
6915 jj_consume_token(ARROWSTAR);
6916 break;
6917 case POINTERTO:
6918 jj_consume_token(POINTERTO);
6919 break;
6920 case LPARENTHESIS:
6921 jj_consume_token(LPARENTHESIS);
6922 jj_consume_token(RPARENTHESIS);
6923 break;
6924 case LSQUAREBRACKET:
6925 jj_consume_token(LSQUAREBRACKET);
6926 jj_consume_token(RSQUAREBRACKET);
6927 break;
6928 default:
6929 jj_la1[169] = jj_gen;
6930 jj_consume_token(-1);
6931 throw new ParseException();
6932 }
6933 }
6934
6935 final public void exception_spec() throws ParseException {
6936 jj_consume_token(THROW);
6937 jj_consume_token(LPARENTHESIS);
6938 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6939 case SCOPE:
6940 case AUTO:
6941 case BOOL:
6942 case CHAR:
6943 case CONST:
6944 case DOUBLE:
6945 case ENUM:
6946 case EXTERN:
6947 case FLOAT:
6948 case FRIEND:
6949 case INLINE:
6950 case INT:
6951 case LONG:
6952 case MUTABLE:
6953 case REGISTER:
6954 case SHORT:
6955 case SIGNED:
6956 case STATIC:
6957 case STRUCT:
6958 case CLASS:
6959 case TEMPLATE:
6960 case TYPEDEF:
6961 case TYPENAME:
6962 case UNION:
6963 case UNSIGNED:
6964 case VIRTUAL:
6965 case VOID:
6966 case VOLATILE:
6967 case WCHAR_T:
6968 case ID:
6969 type_id_list();
6970 break;
6971 default:
6972 jj_la1[170] = jj_gen;
6973 ;
6974 }
6975 jj_consume_token(RPARENTHESIS);
6976 }
6977
6978 final public void type_id_list() throws ParseException {
6979 type_id();
6980 label_35:
6981 while (true) {
6982 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
6983 case COMMA:
6984 ;
6985 break;
6986 default:
6987 jj_la1[171] = jj_gen;
6988 break label_35;
6989 }
6990 jj_consume_token(COMMA);
6991 type_id();
6992 }
6993 }
6994
6995 final private boolean jj_2_1(int xla) {
6996 jj_la = xla; jj_lastpos = jj_scanpos = token;
6997 try { return !jj_3_1(); }
6998 catch(LookaheadSuccess ls) { return true; }
6999 finally { jj_save(0, xla); }
7000 }
7001
7002 final private boolean jj_2_2(int xla) {
7003 jj_la = xla; jj_lastpos = jj_scanpos = token;
7004 try { return !jj_3_2(); }
7005 catch(LookaheadSuccess ls) { return true; }
7006 finally { jj_save(1, xla); }
7007 }
7008
7009 final private boolean jj_2_3(int xla) {
7010 jj_la = xla; jj_lastpos = jj_scanpos = token;
7011 try { return !jj_3_3(); }
7012 catch(LookaheadSuccess ls) { return true; }
7013 finally { jj_save(2, xla); }
7014 }
7015
7016 final private boolean jj_2_4(int xla) {
7017 jj_la = xla; jj_lastpos = jj_scanpos = token;
7018 try { return !jj_3_4(); }
7019 catch(LookaheadSuccess ls) { return true; }
7020 finally { jj_save(3, xla); }
7021 }
7022
7023 final private boolean jj_2_5(int xla) {
7024 jj_la = xla; jj_lastpos = jj_scanpos = token;
7025 try { return !jj_3_5(); }
7026 catch(LookaheadSuccess ls) { return true; }
7027 finally { jj_save(4, xla); }
7028 }
7029
7030 final private boolean jj_2_6(int xla) {
7031 jj_la = xla; jj_lastpos = jj_scanpos = token;
7032 try { return !jj_3_6(); }
7033 catch(LookaheadSuccess ls) { return true; }
7034 finally { jj_save(5, xla); }
7035 }
7036
7037 final private boolean jj_2_7(int xla) {
7038 jj_la = xla; jj_lastpos = jj_scanpos = token;
7039 try { return !jj_3_7(); }
7040 catch(LookaheadSuccess ls) { return true; }
7041 finally { jj_save(6, xla); }
7042 }
7043
7044 final private boolean jj_2_8(int xla) {
7045 jj_la = xla; jj_lastpos = jj_scanpos = token;
7046 try { return !jj_3_8(); }
7047 catch(LookaheadSuccess ls) { return true; }
7048 finally { jj_save(7, xla); }
7049 }
7050
7051 final private boolean jj_2_9(int xla) {
7052 jj_la = xla; jj_lastpos = jj_scanpos = token;
7053 try { return !jj_3_9(); }
7054 catch(LookaheadSuccess ls) { return true; }
7055 finally { jj_save(8, xla); }
7056 }
7057
7058 final private boolean jj_2_10(int xla) {
7059 jj_la = xla; jj_lastpos = jj_scanpos = token;
7060 try { return !jj_3_10(); }
7061 catch(LookaheadSuccess ls) { return true; }
7062 finally { jj_save(9, xla); }
7063 }
7064
7065 final private boolean jj_2_11(int xla) {
7066 jj_la = xla; jj_lastpos = jj_scanpos = token;
7067 try { return !jj_3_11(); }
7068 catch(LookaheadSuccess ls) { return true; }
7069 finally { jj_save(10, xla); }
7070 }
7071
7072 final private boolean jj_2_12(int xla) {
7073 jj_la = xla; jj_lastpos = jj_scanpos = token;
7074 try { return !jj_3_12(); }
7075 catch(LookaheadSuccess ls) { return true; }
7076 finally { jj_save(11, xla); }
7077 }
7078
7079 final private boolean jj_2_13(int xla) {
7080 jj_la = xla; jj_lastpos = jj_scanpos = token;
7081 try { return !jj_3_13(); }
7082 catch(LookaheadSuccess ls) { return true; }
7083 finally { jj_save(12, xla); }
7084 }
7085
7086 final private boolean jj_2_14(int xla) {
7087 jj_la = xla; jj_lastpos = jj_scanpos = token;
7088 try { return !jj_3_14(); }
7089 catch(LookaheadSuccess ls) { return true; }
7090 finally { jj_save(13, xla); }
7091 }
7092
7093 final private boolean jj_2_15(int xla) {
7094 jj_la = xla; jj_lastpos = jj_scanpos = token;
7095 try { return !jj_3_15(); }
7096 catch(LookaheadSuccess ls) { return true; }
7097 finally { jj_save(14, xla); }
7098 }
7099
7100 final private boolean jj_2_16(int xla) {
7101 jj_la = xla; jj_lastpos = jj_scanpos = token;
7102 try { return !jj_3_16(); }
7103 catch(LookaheadSuccess ls) { return true; }
7104 finally { jj_save(15, xla); }
7105 }
7106
7107 final private boolean jj_2_17(int xla) {
7108 jj_la = xla; jj_lastpos = jj_scanpos = token;
7109 try { return !jj_3_17(); }
7110 catch(LookaheadSuccess ls) { return true; }
7111 finally { jj_save(16, xla); }
7112 }
7113
7114 final private boolean jj_2_18(int xla) {
7115 jj_la = xla; jj_lastpos = jj_scanpos = token;
7116 try { return !jj_3_18(); }
7117 catch(LookaheadSuccess ls) { return true; }
7118 finally { jj_save(17, xla); }
7119 }
7120
7121 final private boolean jj_2_19(int xla) {
7122 jj_la = xla; jj_lastpos = jj_scanpos = token;
7123 try { return !jj_3_19(); }
7124 catch(LookaheadSuccess ls) { return true; }
7125 finally { jj_save(18, xla); }
7126 }
7127
7128 final private boolean jj_2_20(int xla) {
7129 jj_la = xla; jj_lastpos = jj_scanpos = token;
7130 try { return !jj_3_20(); }
7131 catch(LookaheadSuccess ls) { return true; }
7132 finally { jj_save(19, xla); }
7133 }
7134
7135 final private boolean jj_2_21(int xla) {
7136 jj_la = xla; jj_lastpos = jj_scanpos = token;
7137 try { return !jj_3_21(); }
7138 catch(LookaheadSuccess ls) { return true; }
7139 finally { jj_save(20, xla); }
7140 }
7141
7142 final private boolean jj_2_22(int xla) {
7143 jj_la = xla; jj_lastpos = jj_scanpos = token;
7144 try { return !jj_3_22(); }
7145 catch(LookaheadSuccess ls) { return true; }
7146 finally { jj_save(21, xla); }
7147 }
7148
7149 final private boolean jj_2_23(int xla) {
7150 jj_la = xla; jj_lastpos = jj_scanpos = token;
7151 try { return !jj_3_23(); }
7152 catch(LookaheadSuccess ls) { return true; }
7153 finally { jj_save(22, xla); }
7154 }
7155
7156 final private boolean jj_2_24(int xla) {
7157 jj_la = xla; jj_lastpos = jj_scanpos = token;
7158 try { return !jj_3_24(); }
7159 catch(LookaheadSuccess ls) { return true; }
7160 finally { jj_save(23, xla); }
7161 }
7162
7163 final private boolean jj_2_25(int xla) {
7164 jj_la = xla; jj_lastpos = jj_scanpos = token;
7165 try { return !jj_3_25(); }
7166 catch(LookaheadSuccess ls) { return true; }
7167 finally { jj_save(24, xla); }
7168 }
7169
7170 final private boolean jj_2_26(int xla) {
7171 jj_la = xla; jj_lastpos = jj_scanpos = token;
7172 try { return !jj_3_26(); }
7173 catch(LookaheadSuccess ls) { return true; }
7174 finally { jj_save(25, xla); }
7175 }
7176
7177 final private boolean jj_2_27(int xla) {
7178 jj_la = xla; jj_lastpos = jj_scanpos = token;
7179 try { return !jj_3_27(); }
7180 catch(LookaheadSuccess ls) { return true; }
7181 finally { jj_save(26, xla); }
7182 }
7183
7184 final private boolean jj_2_28(int xla) {
7185 jj_la = xla; jj_lastpos = jj_scanpos = token;
7186 try { return !jj_3_28(); }
7187 catch(LookaheadSuccess ls) { return true; }
7188 finally { jj_save(27, xla); }
7189 }
7190
7191 final private boolean jj_2_29(int xla) {
7192 jj_la = xla; jj_lastpos = jj_scanpos = token;
7193 try { return !jj_3_29(); }
7194 catch(LookaheadSuccess ls) { return true; }
7195 finally { jj_save(28, xla); }
7196 }
7197
7198 final private boolean jj_2_30(int xla) {
7199 jj_la = xla; jj_lastpos = jj_scanpos = token;
7200 try { return !jj_3_30(); }
7201 catch(LookaheadSuccess ls) { return true; }
7202 finally { jj_save(29, xla); }
7203 }
7204
7205 final private boolean jj_2_31(int xla) {
7206 jj_la = xla; jj_lastpos = jj_scanpos = token;
7207 try { return !jj_3_31(); }
7208 catch(LookaheadSuccess ls) { return true; }
7209 finally { jj_save(30, xla); }
7210 }
7211
7212 final private boolean jj_2_32(int xla) {
7213 jj_la = xla; jj_lastpos = jj_scanpos = token;
7214 try { return !jj_3_32(); }
7215 catch(LookaheadSuccess ls) { return true; }
7216 finally { jj_save(31, xla); }
7217 }
7218
7219 final private boolean jj_2_33(int xla) {
7220 jj_la = xla; jj_lastpos = jj_scanpos = token;
7221 try { return !jj_3_33(); }
7222 catch(LookaheadSuccess ls) { return true; }
7223 finally { jj_save(32, xla); }
7224 }
7225
7226 final private boolean jj_2_34(int xla) {
7227 jj_la = xla; jj_lastpos = jj_scanpos = token;
7228 try { return !jj_3_34(); }
7229 catch(LookaheadSuccess ls) { return true; }
7230 finally { jj_save(33, xla); }
7231 }
7232
7233 final private boolean jj_2_35(int xla) {
7234 jj_la = xla; jj_lastpos = jj_scanpos = token;
7235 try { return !jj_3_35(); }
7236 catch(LookaheadSuccess ls) { return true; }
7237 finally { jj_save(34, xla); }
7238 }
7239
7240 final private boolean jj_2_36(int xla) {
7241 jj_la = xla; jj_lastpos = jj_scanpos = token;
7242 try { return !jj_3_36(); }
7243 catch(LookaheadSuccess ls) { return true; }
7244 finally { jj_save(35, xla); }
7245 }
7246
7247 final private boolean jj_2_37(int xla) {
7248 jj_la = xla; jj_lastpos = jj_scanpos = token;
7249 try { return !jj_3_37(); }
7250 catch(LookaheadSuccess ls) { return true; }
7251 finally { jj_save(36, xla); }
7252 }
7253
7254 final private boolean jj_2_38(int xla) {
7255 jj_la = xla; jj_lastpos = jj_scanpos = token;
7256 try { return !jj_3_38(); }
7257 catch(LookaheadSuccess ls) { return true; }
7258 finally { jj_save(37, xla); }
7259 }
7260
7261 final private boolean jj_2_39(int xla) {
7262 jj_la = xla; jj_lastpos = jj_scanpos = token;
7263 try { return !jj_3_39(); }
7264 catch(LookaheadSuccess ls) { return true; }
7265 finally { jj_save(38, xla); }
7266 }
7267
7268 final private boolean jj_2_40(int xla) {
7269 jj_la = xla; jj_lastpos = jj_scanpos = token;
7270 try { return !jj_3_40(); }
7271 catch(LookaheadSuccess ls) { return true; }
7272 finally { jj_save(39, xla); }
7273 }
7274
7275 final private boolean jj_2_41(int xla) {
7276 jj_la = xla; jj_lastpos = jj_scanpos = token;
7277 try { return !jj_3_41(); }
7278 catch(LookaheadSuccess ls) { return true; }
7279 finally { jj_save(40, xla); }
7280 }
7281
7282 final private boolean jj_2_42(int xla) {
7283 jj_la = xla; jj_lastpos = jj_scanpos = token;
7284 try { return !jj_3_42(); }
7285 catch(LookaheadSuccess ls) { return true; }
7286 finally { jj_save(41, xla); }
7287 }
7288
7289 final private boolean jj_2_43(int xla) {
7290 jj_la = xla; jj_lastpos = jj_scanpos = token;
7291 try { return !jj_3_43(); }
7292 catch(LookaheadSuccess ls) { return true; }
7293 finally { jj_save(42, xla); }
7294 }
7295
7296 final private boolean jj_2_44(int xla) {
7297 jj_la = xla; jj_lastpos = jj_scanpos = token;
7298 try { return !jj_3_44(); }
7299 catch(LookaheadSuccess ls) { return true; }
7300 finally { jj_save(43, xla); }
7301 }
7302
7303 final private boolean jj_2_45(int xla) {
7304 jj_la = xla; jj_lastpos = jj_scanpos = token;
7305 try { return !jj_3_45(); }
7306 catch(LookaheadSuccess ls) { return true; }
7307 finally { jj_save(44, xla); }
7308 }
7309
7310 final private boolean jj_2_46(int xla) {
7311 jj_la = xla; jj_lastpos = jj_scanpos = token;
7312 try { return !jj_3_46(); }
7313 catch(LookaheadSuccess ls) { return true; }
7314 finally { jj_save(45, xla); }
7315 }
7316
7317 final private boolean jj_2_47(int xla) {
7318 jj_la = xla; jj_lastpos = jj_scanpos = token;
7319 try { return !jj_3_47(); }
7320 catch(LookaheadSuccess ls) { return true; }
7321 finally { jj_save(46, xla); }
7322 }
7323
7324 final private boolean jj_2_48(int xla) {
7325 jj_la = xla; jj_lastpos = jj_scanpos = token;
7326 try { return !jj_3_48(); }
7327 catch(LookaheadSuccess ls) { return true; }
7328 finally { jj_save(47, xla); }
7329 }
7330
7331 final private boolean jj_2_49(int xla) {
7332 jj_la = xla; jj_lastpos = jj_scanpos = token;
7333 try { return !jj_3_49(); }
7334 catch(LookaheadSuccess ls) { return true; }
7335 finally { jj_save(48, xla); }
7336 }
7337
7338 final private boolean jj_2_50(int xla) {
7339 jj_la = xla; jj_lastpos = jj_scanpos = token;
7340 try { return !jj_3_50(); }
7341 catch(LookaheadSuccess ls) { return true; }
7342 finally { jj_save(49, xla); }
7343 }
7344
7345 final private boolean jj_2_51(int xla) {
7346 jj_la = xla; jj_lastpos = jj_scanpos = token;
7347 try { return !jj_3_51(); }
7348 catch(LookaheadSuccess ls) { return true; }
7349 finally { jj_save(50, xla); }
7350 }
7351
7352 final private boolean jj_2_52(int xla) {
7353 jj_la = xla; jj_lastpos = jj_scanpos = token;
7354 try { return !jj_3_52(); }
7355 catch(LookaheadSuccess ls) { return true; }
7356 finally { jj_save(51, xla); }
7357 }
7358
7359 final private boolean jj_2_53(int xla) {
7360 jj_la = xla; jj_lastpos = jj_scanpos = token;
7361 try { return !jj_3_53(); }
7362 catch(LookaheadSuccess ls) { return true; }
7363 finally { jj_save(52, xla); }
7364 }
7365
7366 final private boolean jj_2_54(int xla) {
7367 jj_la = xla; jj_lastpos = jj_scanpos = token;
7368 try { return !jj_3_54(); }
7369 catch(LookaheadSuccess ls) { return true; }
7370 finally { jj_save(53, xla); }
7371 }
7372
7373 final private boolean jj_2_55(int xla) {
7374 jj_la = xla; jj_lastpos = jj_scanpos = token;
7375 try { return !jj_3_55(); }
7376 catch(LookaheadSuccess ls) { return true; }
7377 finally { jj_save(54, xla); }
7378 }
7379
7380 final private boolean jj_2_56(int xla) {
7381 jj_la = xla; jj_lastpos = jj_scanpos = token;
7382 try { return !jj_3_56(); }
7383 catch(LookaheadSuccess ls) { return true; }
7384 finally { jj_save(55, xla); }
7385 }
7386
7387 final private boolean jj_2_57(int xla) {
7388 jj_la = xla; jj_lastpos = jj_scanpos = token;
7389 try { return !jj_3_57(); }
7390 catch(LookaheadSuccess ls) { return true; }
7391 finally { jj_save(56, xla); }
7392 }
7393
7394 final private boolean jj_2_58(int xla) {
7395 jj_la = xla; jj_lastpos = jj_scanpos = token;
7396 try { return !jj_3_58(); }
7397 catch(LookaheadSuccess ls) { return true; }
7398 finally { jj_save(57, xla); }
7399 }
7400
7401 final private boolean jj_2_59(int xla) {
7402 jj_la = xla; jj_lastpos = jj_scanpos = token;
7403 try { return !jj_3_59(); }
7404 catch(LookaheadSuccess ls) { return true; }
7405 finally { jj_save(58, xla); }
7406 }
7407
7408 final private boolean jj_2_60(int xla) {
7409 jj_la = xla; jj_lastpos = jj_scanpos = token;
7410 try { return !jj_3_60(); }
7411 catch(LookaheadSuccess ls) { return true; }
7412 finally { jj_save(59, xla); }
7413 }
7414
7415 final private boolean jj_2_61(int xla) {
7416 jj_la = xla; jj_lastpos = jj_scanpos = token;
7417 try { return !jj_3_61(); }
7418 catch(LookaheadSuccess ls) { return true; }
7419 finally { jj_save(60, xla); }
7420 }
7421
7422 final private boolean jj_2_62(int xla) {
7423 jj_la = xla; jj_lastpos = jj_scanpos = token;
7424 try { return !jj_3_62(); }
7425 catch(LookaheadSuccess ls) { return true; }
7426 finally { jj_save(61, xla); }
7427 }
7428
7429 final private boolean jj_2_63(int xla) {
7430 jj_la = xla; jj_lastpos = jj_scanpos = token;
7431 try { return !jj_3_63(); }
7432 catch(LookaheadSuccess ls) { return true; }
7433 finally { jj_save(62, xla); }
7434 }
7435
7436 final private boolean jj_2_64(int xla) {
7437 jj_la = xla; jj_lastpos = jj_scanpos = token;
7438 try { return !jj_3_64(); }
7439 catch(LookaheadSuccess ls) { return true; }
7440 finally { jj_save(63, xla); }
7441 }
7442
7443 final private boolean jj_2_65(int xla) {
7444 jj_la = xla; jj_lastpos = jj_scanpos = token;
7445 try { return !jj_3_65(); }
7446 catch(LookaheadSuccess ls) { return true; }
7447 finally { jj_save(64, xla); }
7448 }
7449
7450 final private boolean jj_2_66(int xla) {
7451 jj_la = xla; jj_lastpos = jj_scanpos = token;
7452 try { return !jj_3_66(); }
7453 catch(LookaheadSuccess ls) { return true; }
7454 finally { jj_save(65, xla); }
7455 }
7456
7457 final private boolean jj_2_67(int xla) {
7458 jj_la = xla; jj_lastpos = jj_scanpos = token;
7459 try { return !jj_3_67(); }
7460 catch(LookaheadSuccess ls) { return true; }
7461 finally { jj_save(66, xla); }
7462 }
7463
7464 final private boolean jj_2_68(int xla) {
7465 jj_la = xla; jj_lastpos = jj_scanpos = token;
7466 try { return !jj_3_68(); }
7467 catch(LookaheadSuccess ls) { return true; }
7468 finally { jj_save(67, xla); }
7469 }
7470
7471 final private boolean jj_2_69(int xla) {
7472 jj_la = xla; jj_lastpos = jj_scanpos = token;
7473 try { return !jj_3_69(); }
7474 catch(LookaheadSuccess ls) { return true; }
7475 finally { jj_save(68, xla); }
7476 }
7477
7478 final private boolean jj_2_70(int xla) {
7479 jj_la = xla; jj_lastpos = jj_scanpos = token;
7480 try { return !jj_3_70(); }
7481 catch(LookaheadSuccess ls) { return true; }
7482 finally { jj_save(69, xla); }
7483 }
7484
7485 final private boolean jj_2_71(int xla) {
7486 jj_la = xla; jj_lastpos = jj_scanpos = token;
7487 try { return !jj_3_71(); }
7488 catch(LookaheadSuccess ls) { return true; }
7489 finally { jj_save(70, xla); }
7490 }
7491
7492 final private boolean jj_2_72(int xla) {
7493 jj_la = xla; jj_lastpos = jj_scanpos = token;
7494 try { return !jj_3_72(); }
7495 catch(LookaheadSuccess ls) { return true; }
7496 finally { jj_save(71, xla); }
7497 }
7498
7499 final private boolean jj_2_73(int xla) {
7500 jj_la = xla; jj_lastpos = jj_scanpos = token;
7501 try { return !jj_3_73(); }
7502 catch(LookaheadSuccess ls) { return true; }
7503 finally { jj_save(72, xla); }
7504 }
7505
7506 final private boolean jj_2_74(int xla) {
7507 jj_la = xla; jj_lastpos = jj_scanpos = token;
7508 try { return !jj_3_74(); }
7509 catch(LookaheadSuccess ls) { return true; }
7510 finally { jj_save(73, xla); }
7511 }
7512
7513 final private boolean jj_2_75(int xla) {
7514 jj_la = xla; jj_lastpos = jj_scanpos = token;
7515 try { return !jj_3_75(); }
7516 catch(LookaheadSuccess ls) { return true; }
7517 finally { jj_save(74, xla); }
7518 }
7519
7520 final private boolean jj_2_76(int xla) {
7521 jj_la = xla; jj_lastpos = jj_scanpos = token;
7522 try { return !jj_3_76(); }
7523 catch(LookaheadSuccess ls) { return true; }
7524 finally { jj_save(75, xla); }
7525 }
7526
7527 final private boolean jj_2_77(int xla) {
7528 jj_la = xla; jj_lastpos = jj_scanpos = token;
7529 try { return !jj_3_77(); }
7530 catch(LookaheadSuccess ls) { return true; }
7531 finally { jj_save(76, xla); }
7532 }
7533
7534 final private boolean jj_2_78(int xla) {
7535 jj_la = xla; jj_lastpos = jj_scanpos = token;
7536 try { return !jj_3_78(); }
7537 catch(LookaheadSuccess ls) { return true; }
7538 finally { jj_save(77, xla); }
7539 }
7540
7541 final private boolean jj_2_79(int xla) {
7542 jj_la = xla; jj_lastpos = jj_scanpos = token;
7543 try { return !jj_3_79(); }
7544 catch(LookaheadSuccess ls) { return true; }
7545 finally { jj_save(78, xla); }
7546 }
7547
7548 final private boolean jj_2_80(int xla) {
7549 jj_la = xla; jj_lastpos = jj_scanpos = token;
7550 try { return !jj_3_80(); }
7551 catch(LookaheadSuccess ls) { return true; }
7552 finally { jj_save(79, xla); }
7553 }
7554
7555 final private boolean jj_2_81(int xla) {
7556 jj_la = xla; jj_lastpos = jj_scanpos = token;
7557 try { return !jj_3_81(); }
7558 catch(LookaheadSuccess ls) { return true; }
7559 finally { jj_save(80, xla); }
7560 }
7561
7562 final private boolean jj_2_82(int xla) {
7563 jj_la = xla; jj_lastpos = jj_scanpos = token;
7564 try { return !jj_3_82(); }
7565 catch(LookaheadSuccess ls) { return true; }
7566 finally { jj_save(81, xla); }
7567 }
7568
7569 final private boolean jj_2_83(int xla) {
7570 jj_la = xla; jj_lastpos = jj_scanpos = token;
7571 try { return !jj_3_83(); }
7572 catch(LookaheadSuccess ls) { return true; }
7573 finally { jj_save(82, xla); }
7574 }
7575
7576 final private boolean jj_2_84(int xla) {
7577 jj_la = xla; jj_lastpos = jj_scanpos = token;
7578 try { return !jj_3_84(); }
7579 catch(LookaheadSuccess ls) { return true; }
7580 finally { jj_save(83, xla); }
7581 }
7582
7583 final private boolean jj_2_85(int xla) {
7584 jj_la = xla; jj_lastpos = jj_scanpos = token;
7585 try { return !jj_3_85(); }
7586 catch(LookaheadSuccess ls) { return true; }
7587 finally { jj_save(84, xla); }
7588 }
7589
7590 final private boolean jj_2_86(int xla) {
7591 jj_la = xla; jj_lastpos = jj_scanpos = token;
7592 try { return !jj_3_86(); }
7593 catch(LookaheadSuccess ls) { return true; }
7594 finally { jj_save(85, xla); }
7595 }
7596
7597 final private boolean jj_2_87(int xla) {
7598 jj_la = xla; jj_lastpos = jj_scanpos = token;
7599 try { return !jj_3_87(); }
7600 catch(LookaheadSuccess ls) { return true; }
7601 finally { jj_save(86, xla); }
7602 }
7603
7604 final private boolean jj_2_88(int xla) {
7605 jj_la = xla; jj_lastpos = jj_scanpos = token;
7606 try { return !jj_3_88(); }
7607 catch(LookaheadSuccess ls) { return true; }
7608 finally { jj_save(87, xla); }
7609 }
7610
7611 final private boolean jj_2_89(int xla) {
7612 jj_la = xla; jj_lastpos = jj_scanpos = token;
7613 try { return !jj_3_89(); }
7614 catch(LookaheadSuccess ls) { return true; }
7615 finally { jj_save(88, xla); }
7616 }
7617
7618 final private boolean jj_2_90(int xla) {
7619 jj_la = xla; jj_lastpos = jj_scanpos = token;
7620 try { return !jj_3_90(); }
7621 catch(LookaheadSuccess ls) { return true; }
7622 finally { jj_save(89, xla); }
7623 }
7624
7625 final private boolean jj_2_91(int xla) {
7626 jj_la = xla; jj_lastpos = jj_scanpos = token;
7627 try { return !jj_3_91(); }
7628 catch(LookaheadSuccess ls) { return true; }
7629 finally { jj_save(90, xla); }
7630 }
7631
7632 final private boolean jj_2_92(int xla) {
7633 jj_la = xla; jj_lastpos = jj_scanpos = token;
7634 try { return !jj_3_92(); }
7635 catch(LookaheadSuccess ls) { return true; }
7636 finally { jj_save(91, xla); }
7637 }
7638
7639 final private boolean jj_2_93(int xla) {
7640 jj_la = xla; jj_lastpos = jj_scanpos = token;
7641 try { return !jj_3_93(); }
7642 catch(LookaheadSuccess ls) { return true; }
7643 finally { jj_save(92, xla); }
7644 }
7645
7646 final private boolean jj_2_94(int xla) {
7647 jj_la = xla; jj_lastpos = jj_scanpos = token;
7648 try { return !jj_3_94(); }
7649 catch(LookaheadSuccess ls) { return true; }
7650 finally { jj_save(93, xla); }
7651 }
7652
7653 final private boolean jj_2_95(int xla) {
7654 jj_la = xla; jj_lastpos = jj_scanpos = token;
7655 try { return !jj_3_95(); }
7656 catch(LookaheadSuccess ls) { return true; }
7657 finally { jj_save(94, xla); }
7658 }
7659
7660 final private boolean jj_2_96(int xla) {
7661 jj_la = xla; jj_lastpos = jj_scanpos = token;
7662 try { return !jj_3_96(); }
7663 catch(LookaheadSuccess ls) { return true; }
7664 finally { jj_save(95, xla); }
7665 }
7666
7667 final private boolean jj_2_97(int xla) {
7668 jj_la = xla; jj_lastpos = jj_scanpos = token;
7669 try { return !jj_3_97(); }
7670 catch(LookaheadSuccess ls) { return true; }
7671 finally { jj_save(96, xla); }
7672 }
7673
7674 final private boolean jj_2_98(int xla) {
7675 jj_la = xla; jj_lastpos = jj_scanpos = token;
7676 try { return !jj_3_98(); }
7677 catch(LookaheadSuccess ls) { return true; }
7678 finally { jj_save(97, xla); }
7679 }
7680
7681 final private boolean jj_2_99(int xla) {
7682 jj_la = xla; jj_lastpos = jj_scanpos = token;
7683 try { return !jj_3_99(); }
7684 catch(LookaheadSuccess ls) { return true; }
7685 finally { jj_save(98, xla); }
7686 }
7687
7688 final private boolean jj_2_100(int xla) {
7689 jj_la = xla; jj_lastpos = jj_scanpos = token;
7690 try { return !jj_3_100(); }
7691 catch(LookaheadSuccess ls) { return true; }
7692 finally { jj_save(99, xla); }
7693 }
7694
7695 final private boolean jj_2_101(int xla) {
7696 jj_la = xla; jj_lastpos = jj_scanpos = token;
7697 try { return !jj_3_101(); }
7698 catch(LookaheadSuccess ls) { return true; }
7699 finally { jj_save(100, xla); }
7700 }
7701
7702 final private boolean jj_2_102(int xla) {
7703 jj_la = xla; jj_lastpos = jj_scanpos = token;
7704 try { return !jj_3_102(); }
7705 catch(LookaheadSuccess ls) { return true; }
7706 finally { jj_save(101, xla); }
7707 }
7708
7709 final private boolean jj_2_103(int xla) {
7710 jj_la = xla; jj_lastpos = jj_scanpos = token;
7711 try { return !jj_3_103(); }
7712 catch(LookaheadSuccess ls) { return true; }
7713 finally { jj_save(102, xla); }
7714 }
7715
7716 final private boolean jj_3R_359() {
7717 if (jj_3R_70()) return true;
7718 Token xsp;
7719 while (true) {
7720 xsp = jj_scanpos;
7721 if (jj_3_58()) { jj_scanpos = xsp; break; }
7722 }
7723 return false;
7724 }
7725
7726 final private boolean jj_3R_128() {
7727 if (jj_3R_182()) return true;
7728 return false;
7729 }
7730
7731 final private boolean jj_3R_427() {
7732 if (jj_3R_175()) return true;
7733 return false;
7734 }
7735
7736 final private boolean jj_3R_408() {
7737 if (jj_scan_token(TILDE)) return true;
7738 if (jj_scan_token(ID)) return true;
7739 if (jj_scan_token(LPARENTHESIS)) return true;
7740 Token xsp;
7741 xsp = jj_scanpos;
7742 if (jj_scan_token(109)) jj_scanpos = xsp;
7743 if (jj_scan_token(RPARENTHESIS)) return true;
7744 xsp = jj_scanpos;
7745 if (jj_3R_417()) jj_scanpos = xsp;
7746 return false;
7747 }
7748
7749 final private boolean jj_3R_418() {
7750 if (jj_3R_420()) return true;
7751 return false;
7752 }
7753
7754 final private boolean jj_3R_99() {
7755 if (jj_3R_68()) return true;
7756 return false;
7757 }
7758
7759 final private boolean jj_3_57() {
7760 if (jj_3R_69()) return true;
7761 return false;
7762 }
7763
7764 final private boolean jj_3R_40() {
7765 Token xsp;
7766 xsp = jj_scanpos;
7767 if (jj_3R_99()) jj_scanpos = xsp;
7768 if (jj_scan_token(TILDE)) return true;
7769 if (jj_scan_token(ID)) return true;
7770 if (jj_scan_token(LPARENTHESIS)) return true;
7771 xsp = jj_scanpos;
7772 if (jj_scan_token(109)) jj_scanpos = xsp;
7773 if (jj_scan_token(RPARENTHESIS)) return true;
7774 xsp = jj_scanpos;
7775 if (jj_3R_100()) jj_scanpos = xsp;
7776 return false;
7777 }
7778
7779 final private boolean jj_3R_424() {
7780 if (jj_scan_token(COMMA)) return true;
7781 if (jj_3R_423()) return true;
7782 return false;
7783 }
7784
7785 final private boolean jj_3R_416() {
7786 if (jj_3R_126()) return true;
7787 return false;
7788 }
7789
7790 final private boolean jj_3R_258() {
7791 Token xsp;
7792 xsp = jj_scanpos;
7793 if (jj_scan_token(108)) {
7794 jj_scanpos = xsp;
7795 if (jj_scan_token(73)) return true;
7796 }
7797 return false;
7798 }
7799
7800 final private boolean jj_3_56() {
7801 if (jj_3R_68()) return true;
7802 return false;
7803 }
7804
7805 final private boolean jj_3R_430() {
7806 if (jj_3R_69()) return true;
7807 return false;
7808 }
7809
7810 final private boolean jj_3R_429() {
7811 Token xsp;
7812 xsp = jj_scanpos;
7813 if (jj_3R_430()) {
7814 jj_scanpos = xsp;
7815 if (jj_scan_token(134)) return true;
7816 }
7817 return false;
7818 }
7819
7820 final private boolean jj_3R_428() {
7821 if (jj_3R_68()) return true;
7822 return false;
7823 }
7824
7825 final private boolean jj_3R_181() {
7826 if (jj_scan_token(INLINE)) return true;
7827 Token xsp;
7828 xsp = jj_scanpos;
7829 if (jj_3R_258()) jj_scanpos = xsp;
7830 return false;
7831 }
7832
7833 final private boolean jj_3R_426() {
7834 Token xsp;
7835 xsp = jj_scanpos;
7836 if (jj_3R_428()) jj_scanpos = xsp;
7837 if (jj_3R_429()) return true;
7838 return false;
7839 }
7840
7841 final private boolean jj_3R_423() {
7842 if (jj_3R_426()) return true;
7843 if (jj_scan_token(LPARENTHESIS)) return true;
7844 Token xsp;
7845 xsp = jj_scanpos;
7846 if (jj_3R_427()) jj_scanpos = xsp;
7847 if (jj_scan_token(RPARENTHESIS)) return true;
7848 return false;
7849 }
7850
7851 final private boolean jj_3R_191() {
7852 if (jj_3R_126()) return true;
7853 return false;
7854 }
7855
7856 final private boolean jj_3R_420() {
7857 if (jj_scan_token(COLON)) return true;
7858 if (jj_3R_423()) return true;
7859 Token xsp;
7860 while (true) {
7861 xsp = jj_scanpos;
7862 if (jj_3R_424()) { jj_scanpos = xsp; break; }
7863 }
7864 return false;
7865 }
7866
7867 final private boolean jj_3R_61() {
7868 if (jj_3R_127()) return true;
7869 if (jj_3R_113()) return true;
7870 Token xsp;
7871 xsp = jj_scanpos;
7872 if (jj_3R_128()) jj_scanpos = xsp;
7873 return false;
7874 }
7875
7876 final private boolean jj_3R_275() {
7877 if (jj_3R_39()) return true;
7878 if (jj_3R_61()) return true;
7879 Token xsp;
7880 xsp = jj_scanpos;
7881 if (jj_3R_418()) jj_scanpos = xsp;
7882 if (jj_3R_235()) return true;
7883 return false;
7884 }
7885
7886 final private boolean jj_3R_190() {
7887 if (jj_3R_182()) return true;
7888 return false;
7889 }
7890
7891 final private boolean jj_3R_274() {
7892 if (jj_3R_39()) return true;
7893 if (jj_3R_40()) return true;
7894 Token xsp;
7895 xsp = jj_scanpos;
7896 if (jj_3R_416()) jj_scanpos = xsp;
7897 if (jj_3R_235()) return true;
7898 return false;
7899 }
7900
7901 final private boolean jj_3R_98() {
7902 Token xsp;
7903 xsp = jj_scanpos;
7904 if (jj_3R_180()) {
7905 jj_scanpos = xsp;
7906 if (jj_3R_181()) return true;
7907 }
7908 return false;
7909 }
7910
7911 final private boolean jj_3R_180() {
7912 Token xsp;
7913 xsp = jj_scanpos;
7914 if (jj_scan_token(108)) {
7915 jj_scanpos = xsp;
7916 if (jj_scan_token(73)) return true;
7917 }
7918 xsp = jj_scanpos;
7919 if (jj_scan_token(80)) jj_scanpos = xsp;
7920 return false;
7921 }
7922
7923 final private boolean jj_3R_39() {
7924 Token xsp;
7925 xsp = jj_scanpos;
7926 if (jj_3R_98()) jj_scanpos = xsp;
7927 return false;
7928 }
7929
7930 final private boolean jj_3R_262() {
7931 if (jj_3R_102()) return true;
7932 if (jj_3R_113()) return true;
7933 return false;
7934 }
7935
7936 final private boolean jj_3_52() {
7937 if (jj_scan_token(CONST)) return true;
7938 return false;
7939 }
7940
7941 final private boolean jj_3_55() {
7942 if (jj_3R_67()) return true;
7943 return false;
7944 }
7945
7946 final private boolean jj_3_51() {
7947 if (jj_scan_token(VOLATILE)) return true;
7948 return false;
7949 }
7950
7951 final private boolean jj_3R_189() {
7952 if (jj_3R_262()) return true;
7953 return false;
7954 }
7955
7956 final private boolean jj_3_54() {
7957 if (jj_3R_67()) return true;
7958 return false;
7959 }
7960
7961 final private boolean jj_3R_188() {
7962 if (jj_scan_token(LPARENTHESIS)) return true;
7963 if (jj_scan_token(STAR)) return true;
7964 if (jj_3R_262()) return true;
7965 if (jj_scan_token(RPARENTHESIS)) return true;
7966 if (jj_3R_113()) return true;
7967 return false;
7968 }
7969
7970 final private boolean jj_3R_187() {
7971 if (jj_3R_183()) return true;
7972 return false;
7973 }
7974
7975 final private boolean jj_3R_103() {
7976 Token xsp;
7977 xsp = jj_scanpos;
7978 if (jj_3R_187()) jj_scanpos = xsp;
7979 xsp = jj_scanpos;
7980 if (jj_3R_188()) {
7981 jj_scanpos = xsp;
7982 if (jj_3R_189()) return true;
7983 }
7984 if (jj_3R_114()) return true;
7985 xsp = jj_scanpos;
7986 if (jj_3R_190()) jj_scanpos = xsp;
7987 xsp = jj_scanpos;
7988 if (jj_3R_191()) jj_scanpos = xsp;
7989 return false;
7990 }
7991
7992 final private boolean jj_3R_414() {
7993 if (jj_3R_419()) return true;
7994 return false;
7995 }
7996
7997 final private boolean jj_3R_101() {
7998 if (jj_3R_183()) return true;
7999 return false;
8000 }
8001
8002 final private boolean jj_3R_41() {
8003 Token xsp;
8004 xsp = jj_scanpos;
8005 if (jj_3R_101()) jj_scanpos = xsp;
8006 if (jj_3R_102()) return true;
8007 if (jj_scan_token(LPARENTHESIS)) return true;
8008 return false;
8009 }
8010
8011 final private boolean jj_3R_66() {
8012 if (jj_scan_token(VOLATILE)) return true;
8013 Token xsp;
8014 xsp = jj_scanpos;
8015 if (jj_scan_token(65)) jj_scanpos = xsp;
8016 return false;
8017 }
8018
8019 final private boolean jj_3R_65() {
8020 if (jj_scan_token(CONST)) return true;
8021 Token xsp;
8022 xsp = jj_scanpos;
8023 if (jj_scan_token(110)) jj_scanpos = xsp;
8024 return false;
8025 }
8026
8027 final private boolean jj_3_53() {
8028 Token xsp;
8029 xsp = jj_scanpos;
8030 if (jj_3R_65()) {
8031 jj_scanpos = xsp;
8032 if (jj_3R_66()) return true;
8033 }
8034 return false;
8035 }
8036
8037 final private boolean jj_3R_114() {
8038 Token xsp;
8039 xsp = jj_scanpos;
8040 if (jj_3_53()) jj_scanpos = xsp;
8041 return false;
8042 }
8043
8044 final private boolean jj_3R_382() {
8045 if (jj_3R_380()) return true;
8046 return false;
8047 }
8048
8049 final private boolean jj_3R_130() {
8050 if (jj_3R_68()) return true;
8051 if (jj_scan_token(STAR)) return true;
8052 if (jj_3R_114()) return true;
8053 return false;
8054 }
8055
8056 final private boolean jj_3R_129() {
8057 if (jj_scan_token(STAR)) return true;
8058 if (jj_3R_114()) return true;
8059 return false;
8060 }
8061
8062 final private boolean jj_3R_67() {
8063 Token xsp;
8064 xsp = jj_scanpos;
8065 if (jj_scan_token(37)) {
8066 jj_scanpos = xsp;
8067 if (jj_3R_129()) {
8068 jj_scanpos = xsp;
8069 if (jj_3R_130()) return true;
8070 }
8071 }
8072 return false;
8073 }
8074
8075 final private boolean jj_3R_397() {
8076 if (jj_scan_token(ASSIGNEQUAL)) return true;
8077 if (jj_3R_80()) return true;
8078 return false;
8079 }
8080
8081 final private boolean jj_3_50() {
8082 if (jj_scan_token(LCURLYBRACE)) return true;
8083 return false;
8084 }
8085
8086 final private boolean jj_3R_395() {
8087 if (jj_scan_token(ID)) return true;
8088 Token xsp;
8089 xsp = jj_scanpos;
8090 if (jj_3R_397()) jj_scanpos = xsp;
8091 return false;
8092 }
8093
8094 final private boolean jj_3R_390() {
8095 if (jj_3R_395()) return true;
8096 Token xsp;
8097 xsp = jj_scanpos;
8098 if (jj_scan_token(19)) jj_scanpos = xsp;
8099 return false;
8100 }
8101
8102 final private boolean jj_3R_413() {
8103 if (jj_3R_126()) return true;
8104 return false;
8105 }
8106
8107 final private boolean jj_3R_380() {
8108 Token xsp;
8109 if (jj_3R_390()) return true;
8110 while (true) {
8111 xsp = jj_scanpos;
8112 if (jj_3R_390()) { jj_scanpos = xsp; break; }
8113 }
8114 return false;
8115 }
8116
8117 final private boolean jj_3R_358() {
8118 if (jj_scan_token(LCURLYBRACE)) return true;
8119 Token xsp;
8120 xsp = jj_scanpos;
8121 if (jj_3R_382()) jj_scanpos = xsp;
8122 if (jj_scan_token(RCURLYBRACE)) return true;
8123 return false;
8124 }
8125
8126 final private boolean jj_3R_357() {
8127 if (jj_3R_380()) return true;
8128 return false;
8129 }
8130
8131 final private boolean jj_3R_59() {
8132 if (jj_3R_126()) return true;
8133 return false;
8134 }
8135
8136 final private boolean jj_3R_325() {
8137 if (jj_scan_token(ID)) return true;
8138 Token xsp;
8139 xsp = jj_scanpos;
8140 if (jj_3R_358()) jj_scanpos = xsp;
8141 return false;
8142 }
8143
8144 final private boolean jj_3R_422() {
8145 if (jj_scan_token(COMMA)) return true;
8146 if (jj_3R_421()) return true;
8147 return false;
8148 }
8149
8150 final private boolean jj_3R_324() {
8151 if (jj_scan_token(LCURLYBRACE)) return true;
8152 Token xsp;
8153 xsp = jj_scanpos;
8154 if (jj_3R_357()) jj_scanpos = xsp;
8155 if (jj_scan_token(RCURLYBRACE)) return true;
8156 return false;
8157 }
8158
8159 final private boolean jj_3R_425() {
8160 Token xsp;
8161 xsp = jj_scanpos;
8162 if (jj_scan_token(22)) {
8163 jj_scanpos = xsp;
8164 if (jj_scan_token(17)) return true;
8165 }
8166 if (jj_3R_80()) return true;
8167 return false;
8168 }
8169
8170 final private boolean jj_3R_269() {
8171 if (jj_scan_token(ENUM)) return true;
8172 Token xsp;
8173 xsp = jj_scanpos;
8174 if (jj_3R_324()) {
8175 jj_scanpos = xsp;
8176 if (jj_3R_325()) return true;
8177 }
8178 return false;
8179 }
8180
8181 final private boolean jj_3R_126() {
8182 if (jj_scan_token(ASSIGNEQUAL)) return true;
8183 if (jj_scan_token(OCTALINT)) return true;
8184 return false;
8185 }
8186
8187 final private boolean jj_3R_421() {
8188 if (jj_3R_71()) return true;
8189 Token xsp;
8190 xsp = jj_scanpos;
8191 if (jj_3R_425()) jj_scanpos = xsp;
8192 return false;
8193 }
8194
8195 final private boolean jj_3_41() {
8196 if (jj_3R_36()) return true;
8197 return false;
8198 }
8199
8200 final private boolean jj_3R_355() {
8201 if (jj_scan_token(COMMA)) return true;
8202 if (jj_3R_75()) return true;
8203 return false;
8204 }
8205
8206 final private boolean jj_3_49() {
8207 if (jj_scan_token(USING)) return true;
8208 return false;
8209 }
8210
8211 final private boolean jj_3R_419() {
8212 if (jj_3R_421()) return true;
8213 Token xsp;
8214 while (true) {
8215 xsp = jj_scanpos;
8216 if (jj_3R_422()) { jj_scanpos = xsp; break; }
8217 }
8218 return false;
8219 }
8220
8221 final private boolean jj_3_40() {
8222 if (jj_3R_36()) return true;
8223 return false;
8224 }
8225
8226 final private boolean jj_3R_64() {
8227 if (jj_3R_36()) return true;
8228 return false;
8229 }
8230
8231 final private boolean jj_3_48() {
8232 Token xsp;
8233 xsp = jj_scanpos;
8234 if (jj_3R_64()) jj_scanpos = xsp;
8235 if (jj_3R_44()) return true;
8236 return false;
8237 }
8238
8239 final private boolean jj_3R_259() {
8240 if (jj_3R_320()) return true;
8241 return false;
8242 }
8243
8244 final private boolean jj_3_39() {
8245 if (jj_3R_36()) return true;
8246 return false;
8247 }
8248
8249 final private boolean jj_3R_63() {
8250 if (jj_3R_36()) return true;
8251 return false;
8252 }
8253
8254 final private boolean jj_3_47() {
8255 Token xsp;
8256 xsp = jj_scanpos;
8257 if (jj_3R_63()) jj_scanpos = xsp;
8258 if (jj_3R_44()) return true;
8259 if (jj_3R_41()) return true;
8260 return false;
8261 }
8262
8263 final private boolean jj_3_38() {
8264 if (jj_3R_36()) return true;
8265 return false;
8266 }
8267
8268 final private boolean jj_3R_412() {
8269 if (jj_3R_36()) return true;
8270 return false;
8271 }
8272
8273 final private boolean jj_3R_62() {
8274 if (jj_3R_36()) return true;
8275 return false;
8276 }
8277
8278 final private boolean jj_3_46() {
8279 Token xsp;
8280 xsp = jj_scanpos;
8281 if (jj_3R_62()) jj_scanpos = xsp;
8282 if (jj_3R_39()) return true;
8283 if (jj_3R_41()) return true;
8284 return false;
8285 }
8286
8287 final private boolean jj_3R_406() {
8288 if (jj_3R_194()) return true;
8289 return false;
8290 }
8291
8292 final private boolean jj_3R_411() {
8293 if (jj_3R_36()) return true;
8294 return false;
8295 }
8296
8297 final private boolean jj_3R_320() {
8298 if (jj_3R_75()) return true;
8299 Token xsp;
8300 while (true) {
8301 xsp = jj_scanpos;
8302 if (jj_3R_355()) { jj_scanpos = xsp; break; }
8303 }
8304 return false;
8305 }
8306
8307 final private boolean jj_3R_60() {
8308 if (jj_3R_36()) return true;
8309 return false;
8310 }
8311
8312 final private boolean jj_3_45() {
8313 Token xsp;
8314 xsp = jj_scanpos;
8315 if (jj_3R_60()) jj_scanpos = xsp;
8316 if (jj_3R_39()) return true;
8317 if (jj_3R_61()) return true;
8318 if (jj_scan_token(SEMICOLON)) return true;
8319 return false;
8320 }
8321
8322 final private boolean jj_3R_405() {
8323 Token xsp;
8324 xsp = jj_scanpos;
8325 if (jj_3R_412()) jj_scanpos = xsp;
8326 if (jj_3R_44()) return true;
8327 xsp = jj_scanpos;
8328 if (jj_3R_414()) jj_scanpos = xsp;
8329 if (jj_scan_token(SEMICOLON)) return true;
8330 return false;
8331 }
8332
8333 final private boolean jj_3_37() {
8334 if (jj_3R_36()) return true;
8335 return false;
8336 }
8337
8338 final private boolean jj_3R_410() {
8339 if (jj_3R_36()) return true;
8340 return false;
8341 }
8342
8343 final private boolean jj_3_44() {
8344 if (jj_3R_39()) return true;
8345 if (jj_scan_token(TILDE)) return true;
8346 return false;
8347 }
8348
8349 final private boolean jj_3R_404() {
8350 Token xsp;
8351 xsp = jj_scanpos;
8352 if (jj_3R_411()) jj_scanpos = xsp;
8353 if (jj_3R_276()) return true;
8354 return false;
8355 }
8356
8357 final private boolean jj_3R_409() {
8358 if (jj_3R_36()) return true;
8359 return false;
8360 }
8361
8362 final private boolean jj_3R_182() {
8363 if (jj_scan_token(THROW)) return true;
8364 if (jj_scan_token(LPARENTHESIS)) return true;
8365 Token xsp;
8366 xsp = jj_scanpos;
8367 if (jj_3R_259()) jj_scanpos = xsp;
8368 if (jj_scan_token(RPARENTHESIS)) return true;
8369 return false;
8370 }
8371
8372 final private boolean jj_3_43() {
8373 if (jj_3R_39()) return true;
8374 if (jj_3R_40()) return true;
8375 Token xsp;
8376 xsp = jj_scanpos;
8377 if (jj_3R_59()) jj_scanpos = xsp;
8378 if (jj_scan_token(LCURLYBRACE)) return true;
8379 return false;
8380 }
8381
8382 final private boolean jj_3R_403() {
8383 Token xsp;
8384 xsp = jj_scanpos;
8385 if (jj_3R_410()) jj_scanpos = xsp;
8386 if (jj_3R_275()) return true;
8387 return false;
8388 }
8389
8390 final private boolean jj_3R_58() {
8391 if (jj_3R_49()) return true;
8392 return false;
8393 }
8394
8395 final private boolean jj_3_42() {
8396 Token xsp;
8397 while (true) {
8398 xsp = jj_scanpos;
8399 if (jj_3R_58()) { jj_scanpos = xsp; break; }
8400 }
8401 if (jj_scan_token(OPERATOR)) return true;
8402 return false;
8403 }
8404
8405 final private boolean jj_3R_174() {
8406 if (jj_scan_token(LSQUAREBRACKET)) return true;
8407 if (jj_scan_token(RSQUAREBRACKET)) return true;
8408 return false;
8409 }
8410
8411 final private boolean jj_3R_402() {
8412 Token xsp;
8413 xsp = jj_scanpos;
8414 if (jj_3R_409()) jj_scanpos = xsp;
8415 if (jj_3R_39()) return true;
8416 if (jj_3R_61()) return true;
8417 if (jj_scan_token(SEMICOLON)) return true;
8418 return false;
8419 }
8420
8421 final private boolean jj_3R_173() {
8422 if (jj_scan_token(LPARENTHESIS)) return true;
8423 if (jj_scan_token(RPARENTHESIS)) return true;
8424 return false;
8425 }
8426
8427 final private boolean jj_3R_407() {
8428 if (jj_3R_36()) return true;
8429 return false;
8430 }
8431
8432 final private boolean jj_3R_362() {
8433 if (jj_3R_57()) return true;
8434 Token xsp;
8435 xsp = jj_scanpos;
8436 if (jj_scan_token(108)) jj_scanpos = xsp;
8437 return false;
8438 }
8439
8440 final private boolean jj_3R_401() {
8441 if (jj_3R_39()) return true;
8442 if (jj_3R_408()) return true;
8443 Token xsp;
8444 xsp = jj_scanpos;
8445 if (jj_3R_413()) jj_scanpos = xsp;
8446 if (jj_scan_token(SEMICOLON)) return true;
8447 return false;
8448 }
8449
8450 final private boolean jj_3R_400() {
8451 Token xsp;
8452 xsp = jj_scanpos;
8453 if (jj_3R_407()) jj_scanpos = xsp;
8454 if (jj_3R_274()) return true;
8455 return false;
8456 }
8457
8458 final private boolean jj_3R_399() {
8459 if (jj_3R_273()) return true;
8460 return false;
8461 }
8462
8463 final private boolean jj_3R_396() {
8464 Token xsp;
8465 xsp = jj_scanpos;
8466 if (jj_3R_399()) {
8467 jj_scanpos = xsp;
8468 if (jj_3R_400()) {
8469 jj_scanpos = xsp;
8470 if (jj_3R_401()) {
8471 jj_scanpos = xsp;
8472 if (jj_3R_402()) {
8473 jj_scanpos = xsp;
8474 if (jj_3R_403()) {
8475 jj_scanpos = xsp;
8476 if (jj_3R_404()) {
8477 jj_scanpos = xsp;
8478 if (jj_3R_405()) {
8479 jj_scanpos = xsp;
8480 if (jj_3R_406()) {
8481 jj_scanpos = xsp;
8482 if (jj_scan_token(18)) return true;
8483 }
8484 }
8485 }
8486 }
8487 }
8488 }
8489 }
8490 }
8491 return false;
8492 }
8493
8494 final private boolean jj_3_33() {
8495 if (jj_scan_token(COMMA)) return true;
8496 return false;
8497 }
8498
8499 final private boolean jj_3_36() {
8500 if (jj_3R_57()) return true;
8501 return false;
8502 }
8503
8504 final private boolean jj_3_35() {
8505 if (jj_3R_53()) return true;
8506 return false;
8507 }
8508
8509 final private boolean jj_3R_57() {
8510 Token xsp;
8511 xsp = jj_scanpos;
8512 if (jj_scan_token(88)) {
8513 jj_scanpos = xsp;
8514 if (jj_scan_token(87)) {
8515 jj_scanpos = xsp;
8516 if (jj_scan_token(86)) return true;
8517 }
8518 }
8519 return false;
8520 }
8521
8522 final private boolean jj_3R_394() {
8523 if (jj_3R_396()) return true;
8524 return false;
8525 }
8526
8527 final private boolean jj_3R_393() {
8528 if (jj_3R_57()) return true;
8529 if (jj_scan_token(COLON)) return true;
8530 return false;
8531 }
8532
8533 final private boolean jj_3R_389() {
8534 Token xsp;
8535 xsp = jj_scanpos;
8536 if (jj_3R_393()) {
8537 jj_scanpos = xsp;
8538 if (jj_3R_394()) return true;
8539 }
8540 return false;
8541 }
8542
8543 final private boolean jj_3R_381() {
8544 if (jj_3R_57()) return true;
8545 return false;
8546 }
8547
8548 final private boolean jj_3R_282() {
8549 if (jj_scan_token(COMMA)) return true;
8550 if (jj_3R_281()) return true;
8551 return false;
8552 }
8553
8554 final private boolean jj_3R_333() {
8555 if (jj_3R_53()) return true;
8556 return false;
8557 }
8558
8559 final private boolean jj_3_34() {
8560 if (jj_3R_46()) return true;
8561 return false;
8562 }
8563
8564 final private boolean jj_3R_379() {
8565 Token xsp;
8566 if (jj_3R_389()) return true;
8567 while (true) {
8568 xsp = jj_scanpos;
8569 if (jj_3R_389()) { jj_scanpos = xsp; break; }
8570 }
8571 return false;
8572 }
8573
8574 final private boolean jj_3_103() {
8575 if (jj_scan_token(LSQUAREBRACKET)) return true;
8576 if (jj_scan_token(RSQUAREBRACKET)) return true;
8577 return false;
8578 }
8579
8580 final private boolean jj_3_102() {
8581 if (jj_scan_token(LSQUAREBRACKET)) return true;
8582 if (jj_scan_token(RSQUAREBRACKET)) return true;
8583 return false;
8584 }
8585
8586 final private boolean jj_3_30() {
8587 if (jj_3R_46()) return true;
8588 return false;
8589 }
8590
8591 final private boolean jj_3_31() {
8592 if (jj_3R_53()) return true;
8593 return false;
8594 }
8595
8596 final private boolean jj_3R_361() {
8597 if (jj_scan_token(VIRTUAL)) return true;
8598 Token xsp;
8599 xsp = jj_scanpos;
8600 if (jj_3R_381()) jj_scanpos = xsp;
8601 return false;
8602 }
8603
8604 final private boolean jj_3R_332() {
8605 if (jj_3R_68()) return true;
8606 return false;
8607 }
8608
8609 final private boolean jj_3R_331() {
8610 Token xsp;
8611 xsp = jj_scanpos;
8612 if (jj_3R_361()) {
8613 jj_scanpos = xsp;
8614 if (jj_3R_362()) return true;
8615 }
8616 return false;
8617 }
8618
8619 final private boolean jj_3R_281() {
8620 Token xsp;
8621 xsp = jj_scanpos;
8622 if (jj_3R_331()) jj_scanpos = xsp;
8623 xsp = jj_scanpos;
8624 if (jj_3R_332()) jj_scanpos = xsp;
8625 if (jj_scan_token(ID)) return true;
8626 xsp = jj_scanpos;
8627 if (jj_3R_333()) jj_scanpos = xsp;
8628 return false;
8629 }
8630
8631 final private boolean jj_3R_172() {
8632 if (jj_scan_token(DELETE)) return true;
8633 Token xsp;
8634 xsp = jj_scanpos;
8635 if (jj_3_103()) jj_scanpos = xsp;
8636 return false;
8637 }
8638
8639 final private boolean jj_3R_93() {
8640 Token xsp;
8641 xsp = jj_scanpos;
8642 if (jj_3R_171()) {
8643 jj_scanpos = xsp;
8644 if (jj_3R_172()) {
8645 jj_scanpos = xsp;
8646 if (jj_scan_token(46)) {
8647 jj_scanpos = xsp;
8648 if (jj_scan_token(47)) {
8649 jj_scanpos = xsp;
8650 if (jj_scan_token(48)) {
8651 jj_scanpos = xsp;
8652 if (jj_scan_token(49)) {
8653 jj_scanpos = xsp;
8654 if (jj_scan_token(50)) {
8655 jj_scanpos = xsp;
8656 if (jj_scan_token(36)) {
8657 jj_scanpos = xsp;
8658 if (jj_scan_token(37)) {
8659 jj_scanpos = xsp;
8660 if (jj_scan_token(35)) {
8661 jj_scanpos = xsp;
8662 if (jj_scan_token(53)) {
8663 jj_scanpos = xsp;
8664 if (jj_scan_token(54)) {
8665 jj_scanpos = xsp;
8666 if (jj_scan_token(22)) {
8667 jj_scanpos = xsp;
8668 if (jj_scan_token(40)) {
8669 jj_scanpos = xsp;
8670 if (jj_scan_token(41)) {
8671 jj_scanpos = xsp;
8672 if (jj_scan_token(26)) {
8673 jj_scanpos = xsp;
8674 if (jj_scan_token(27)) {
8675 jj_scanpos = xsp;
8676 if (jj_scan_token(23)) {
8677 jj_scanpos = xsp;
8678 if (jj_scan_token(24)) {
8679 jj_scanpos = xsp;
8680 if (jj_scan_token(25)) {
8681 jj_scanpos = xsp;
8682 if (jj_scan_token(31)) {
8683 jj_scanpos = xsp;
8684 if (jj_scan_token(30)) {
8685 jj_scanpos = xsp;
8686 if (jj_scan_token(32)) {
8687 jj_scanpos = xsp;
8688 if (jj_scan_token(44)) {
8689 jj_scanpos = xsp;
8690 if (jj_scan_token(45)) {
8691 jj_scanpos = xsp;
8692 if (jj_scan_token(29)) {
8693 jj_scanpos = xsp;
8694 if (jj_scan_token(28)) {
8695 jj_scanpos = xsp;
8696 if (jj_scan_token(38)) {
8697 jj_scanpos = xsp;
8698 if (jj_scan_token(39)) {
8699 jj_scanpos = xsp;
8700 if (jj_scan_token(42)) {
8701 jj_scanpos = xsp;
8702 if (jj_scan_token(43)) {
8703 jj_scanpos = xsp;
8704 if (jj_scan_token(34)) {
8705 jj_scanpos = xsp;
8706 if (jj_scan_token(33)) {
8707 jj_scanpos = xsp;
8708 if (jj_scan_token(51)) {
8709 jj_scanpos = xsp;
8710 if (jj_scan_token(52)) {
8711 jj_scanpos = xsp;
8712 if (jj_scan_token(19)) {
8713 jj_scanpos = xsp;
8714 if (jj_scan_token(58)) {
8715 jj_scanpos = xsp;
8716 if (jj_scan_token(56)) {
8717 jj_scanpos = xsp;
8718 if (jj_3R_173()) {
8719 jj_scanpos = xsp;
8720 if (jj_3R_174()) return true;
8721 }
8722 }
8723 }
8724 }
8725 }
8726 }
8727 }
8728 }
8729 }
8730 }
8731 }
8732 }
8733 }
8734 }
8735 }
8736 }
8737 }
8738 }
8739 }
8740 }
8741 }
8742 }
8743 }
8744 }
8745 }
8746 }
8747 }
8748 }
8749 }
8750 }
8751 }
8752 }
8753 }
8754 }
8755 }
8756 }
8757 }
8758 }
8759 }
8760 return false;
8761 }
8762
8763 final private boolean jj_3R_171() {
8764 if (jj_scan_token(NEW)) return true;
8765 Token xsp;
8766 xsp = jj_scanpos;
8767 if (jj_3_102()) jj_scanpos = xsp;
8768 return false;
8769 }
8770
8771 final private boolean jj_3_32() {
8772 if (jj_scan_token(COLON)) return true;
8773 return false;
8774 }
8775
8776 final private boolean jj_3R_123() {
8777 if (jj_3R_68()) return true;
8778 return false;
8779 }
8780
8781 final private boolean jj_3R_254() {
8782 if (jj_scan_token(COMMA)) return true;
8783 if (jj_3R_80()) return true;
8784 return false;
8785 }
8786
8787 final private boolean jj_3R_124() {
8788 if (jj_3R_53()) return true;
8789 return false;
8790 }
8791
8792 final private boolean jj_3R_222() {
8793 if (jj_scan_token(COLON)) return true;
8794 if (jj_3R_281()) return true;
8795 Token xsp;
8796 while (true) {
8797 xsp = jj_scanpos;
8798 if (jj_3R_282()) { jj_scanpos = xsp; break; }
8799 }
8800 return false;
8801 }
8802
8803 final private boolean jj_3R_125() {
8804 if (jj_3R_222()) return true;
8805 return false;
8806 }
8807
8808 final private boolean jj_3R_56() {
8809 if (jj_3R_55()) return true;
8810 Token xsp;
8811 xsp = jj_scanpos;
8812 if (jj_3R_123()) jj_scanpos = xsp;
8813 if (jj_scan_token(ID)) return true;
8814 xsp = jj_scanpos;
8815 if (jj_3R_124()) jj_scanpos = xsp;
8816 xsp = jj_scanpos;
8817 if (jj_3R_125()) jj_scanpos = xsp;
8818 return false;
8819 }
8820
8821 final private boolean jj_3_100() {
8822 if (jj_3R_96()) return true;
8823 return false;
8824 }
8825
8826 final private boolean jj_3R_317() {
8827 if (jj_scan_token(LSQUAREBRACKET)) return true;
8828 if (jj_scan_token(RSQUAREBRACKET)) return true;
8829 return false;
8830 }
8831
8832 final private boolean jj_3R_253() {
8833 Token xsp;
8834 xsp = jj_scanpos;
8835 if (jj_scan_token(117)) {
8836 jj_scanpos = xsp;
8837 if (jj_scan_token(118)) {
8838 jj_scanpos = xsp;
8839 if (jj_scan_token(121)) {
8840 jj_scanpos = xsp;
8841 if (jj_scan_token(122)) {
8842 jj_scanpos = xsp;
8843 if (jj_scan_token(125)) {
8844 jj_scanpos = xsp;
8845 if (jj_scan_token(126)) {
8846 jj_scanpos = xsp;
8847 if (jj_scan_token(119)) {
8848 jj_scanpos = xsp;
8849 if (jj_scan_token(120)) {
8850 jj_scanpos = xsp;
8851 if (jj_scan_token(123)) {
8852 jj_scanpos = xsp;
8853 if (jj_scan_token(124)) {
8854 jj_scanpos = xsp;
8855 if (jj_scan_token(127)) {
8856 jj_scanpos = xsp;
8857 if (jj_scan_token(128)) {
8858 jj_scanpos = xsp;
8859 if (jj_scan_token(132)) {
8860 jj_scanpos = xsp;
8861 if (jj_scan_token(129)) {
8862 jj_scanpos = xsp;
8863 if (jj_scan_token(130)) {
8864 jj_scanpos = xsp;
8865 if (jj_scan_token(114)) {
8866 jj_scanpos = xsp;
8867 if (jj_scan_token(115)) return true;
8868 }
8869 }
8870 }
8871 }
8872 }
8873 }
8874 }
8875 }
8876 }
8877 }
8878 }
8879 }
8880 }
8881 }
8882 }
8883 }
8884 return false;
8885 }
8886
8887 final private boolean jj_3R_55() {
8888 Token xsp;
8889 xsp = jj_scanpos;
8890 if (jj_scan_token(97)) {
8891 jj_scanpos = xsp;
8892 if (jj_scan_token(96)) {
8893 jj_scanpos = xsp;
8894 if (jj_scan_token(105)) return true;
8895 }
8896 }
8897 return false;
8898 }
8899
8900 final private boolean jj_3_99() {
8901 if (jj_3R_96()) return true;
8902 return false;
8903 }
8904
8905 final private boolean jj_3R_370() {
8906 if (jj_scan_token(LPARENTHESIS)) return true;
8907 if (jj_3R_175()) return true;
8908 if (jj_scan_token(RPARENTHESIS)) return true;
8909 return false;
8910 }
8911
8912 final private boolean jj_3_29() {
8913 if (jj_3R_56()) return true;
8914 if (jj_scan_token(LCURLYBRACE)) return true;
8915 return false;
8916 }
8917
8918 final private boolean jj_3R_175() {
8919 if (jj_3R_80()) return true;
8920 Token xsp;
8921 while (true) {
8922 xsp = jj_scanpos;
8923 if (jj_3R_254()) { jj_scanpos = xsp; break; }
8924 }
8925 return false;
8926 }
8927
8928 final private boolean jj_3R_323() {
8929 if (jj_3R_56()) return true;
8930 return false;
8931 }
8932
8933 final private boolean jj_3R_363() {
8934 if (jj_3R_379()) return true;
8935 return false;
8936 }
8937
8938 final private boolean jj_3R_250() {
8939 Token xsp;
8940 xsp = jj_scanpos;
8941 if (jj_scan_token(16)) jj_scanpos = xsp;
8942 if (jj_scan_token(DELETE)) return true;
8943 xsp = jj_scanpos;
8944 if (jj_3R_317()) jj_scanpos = xsp;
8945 if (jj_3R_85()) return true;
8946 return false;
8947 }
8948
8949 final private boolean jj_3R_375() {
8950 if (jj_3R_96()) return true;
8951 return false;
8952 }
8953
8954 final private boolean jj_3_28() {
8955 if (jj_3R_55()) return true;
8956 if (jj_scan_token(LCURLYBRACE)) return true;
8957 return false;
8958 }
8959
8960 final private boolean jj_3R_176() {
8961 if (jj_3R_175()) return true;
8962 return false;
8963 }
8964
8965 final private boolean jj_3R_54() {
8966 if (jj_3R_122()) return true;
8967 Token xsp;
8968 xsp = jj_scanpos;
8969 if (jj_scan_token(19)) jj_scanpos = xsp;
8970 return false;
8971 }
8972
8973 final private boolean jj_3_101() {
8974 if (jj_scan_token(LSQUAREBRACKET)) return true;
8975 return false;
8976 }
8977
8978 final private boolean jj_3R_322() {
8979 if (jj_3R_56()) return true;
8980 if (jj_scan_token(LCURLYBRACE)) return true;
8981 Token xsp;
8982 xsp = jj_scanpos;
8983 if (jj_3R_363()) jj_scanpos = xsp;
8984 if (jj_scan_token(RCURLYBRACE)) return true;
8985 return false;
8986 }
8987
8988 final private boolean jj_3R_356() {
8989 if (jj_3R_379()) return true;
8990 return false;
8991 }
8992
8993 final private boolean jj_3R_95() {
8994 if (jj_scan_token(LPARENTHESIS)) return true;
8995 Token xsp;
8996 xsp = jj_scanpos;
8997 if (jj_3R_176()) jj_scanpos = xsp;
8998 if (jj_scan_token(RPARENTHESIS)) return true;
8999 return false;
9000 }
9001
9002 final private boolean jj_3_26() {
9003 if (jj_3R_53()) return true;
9004 return false;
9005 }
9006
9007 final private boolean jj_3R_321() {
9008 if (jj_3R_55()) return true;
9009 if (jj_scan_token(LCURLYBRACE)) return true;
9010 Token xsp;
9011 xsp = jj_scanpos;
9012 if (jj_3R_356()) jj_scanpos = xsp;
9013 if (jj_scan_token(RCURLYBRACE)) return true;
9014 return false;
9015 }
9016
9017 final private boolean jj_3R_268() {
9018 Token xsp;
9019 xsp = jj_scanpos;
9020 if (jj_3R_321()) {
9021 jj_scanpos = xsp;
9022 if (jj_3R_322()) {
9023 jj_scanpos = xsp;
9024 if (jj_3R_323()) return true;
9025 }
9026 }
9027 return false;
9028 }
9029
9030 final private boolean jj_3R_318() {
9031 if (jj_scan_token(LSQUAREBRACKET)) return true;
9032 if (jj_3R_78()) return true;
9033 if (jj_scan_token(RSQUAREBRACKET)) return true;
9034 return false;
9035 }
9036
9037 final private boolean jj_3R_369() {
9038 if (jj_scan_token(ASSIGNEQUAL)) return true;
9039 if (jj_3R_122()) return true;
9040 return false;
9041 }
9042
9043 final private boolean jj_3R_346() {
9044 Token xsp;
9045 xsp = jj_scanpos;
9046 if (jj_3R_369()) {
9047 jj_scanpos = xsp;
9048 if (jj_3R_370()) return true;
9049 }
9050 return false;
9051 }
9052
9053 final private boolean jj_3R_255() {
9054 Token xsp;
9055 if (jj_3R_318()) return true;
9056 while (true) {
9057 xsp = jj_scanpos;
9058 if (jj_3R_318()) { jj_scanpos = xsp; break; }
9059 }
9060 return false;
9061 }
9062
9063 final private boolean jj_3R_301() {
9064 if (jj_scan_token(COMMA)) return true;
9065 if (jj_3R_300()) return true;
9066 return false;
9067 }
9068
9069 final private boolean jj_3R_178() {
9070 if (jj_3R_67()) return true;
9071 if (jj_3R_114()) return true;
9072 Token xsp;
9073 xsp = jj_scanpos;
9074 if (jj_3_100()) jj_scanpos = xsp;
9075 return false;
9076 }
9077
9078 final private boolean jj_3R_221() {
9079 if (jj_3R_80()) return true;
9080 return false;
9081 }
9082
9083 final private boolean jj_3R_224() {
9084 if (jj_3R_53()) return true;
9085 return false;
9086 }
9087
9088 final private boolean jj_3R_96() {
9089 Token xsp;
9090 xsp = jj_scanpos;
9091 if (jj_3R_177()) {
9092 jj_scanpos = xsp;
9093 if (jj_3R_178()) return true;
9094 }
9095 return false;
9096 }
9097
9098 final private boolean jj_3R_177() {
9099 if (jj_3R_255()) return true;
9100 return false;
9101 }
9102
9103 final private boolean jj_3_27() {
9104 if (jj_scan_token(LCURLYBRACE)) return true;
9105 Token xsp;
9106 if (jj_3R_54()) return true;
9107 while (true) {
9108 xsp = jj_scanpos;
9109 if (jj_3R_54()) { jj_scanpos = xsp; break; }
9110 }
9111 if (jj_scan_token(RCURLYBRACE)) return true;
9112 return false;
9113 }
9114
9115 final private boolean jj_3R_122() {
9116 Token xsp;
9117 xsp = jj_scanpos;
9118 if (jj_3_27()) {
9119 jj_scanpos = xsp;
9120 if (jj_3R_221()) return true;
9121 }
9122 return false;
9123 }
9124
9125 final private boolean jj_3_96() {
9126 if (jj_3R_94()) return true;
9127 return false;
9128 }
9129
9130 final private boolean jj_3R_354() {
9131 if (jj_3R_44()) return true;
9132 Token xsp;
9133 xsp = jj_scanpos;
9134 if (jj_3R_375()) jj_scanpos = xsp;
9135 return false;
9136 }
9137
9138 final private boolean jj_3R_300() {
9139 if (jj_3R_71()) return true;
9140 Token xsp;
9141 xsp = jj_scanpos;
9142 if (jj_3R_346()) jj_scanpos = xsp;
9143 return false;
9144 }
9145
9146 final private boolean jj_3_25() {
9147 if (jj_3R_46()) return true;
9148 return false;
9149 }
9150
9151 final private boolean jj_3_98() {
9152 if (jj_3R_95()) return true;
9153 return false;
9154 }
9155
9156 final private boolean jj_3R_52() {
9157 if (jj_3R_53()) return true;
9158 return false;
9159 }
9160
9161 final private boolean jj_3_24() {
9162 if (jj_3R_53()) return true;
9163 return false;
9164 }
9165
9166 final private boolean jj_3R_313() {
9167 if (jj_3R_94()) return true;
9168 return false;
9169 }
9170
9171 final private boolean jj_3_97() {
9172 if (jj_scan_token(LPARENTHESIS)) return true;
9173 if (jj_3R_75()) return true;
9174 if (jj_scan_token(RPARENTHESIS)) return true;
9175 return false;
9176 }
9177
9178 final private boolean jj_3R_94() {
9179 if (jj_scan_token(LPARENTHESIS)) return true;
9180 if (jj_3R_175()) return true;
9181 if (jj_scan_token(RPARENTHESIS)) return true;
9182 return false;
9183 }
9184
9185 final private boolean jj_3R_242() {
9186 if (jj_3R_300()) return true;
9187 Token xsp;
9188 while (true) {
9189 xsp = jj_scanpos;
9190 if (jj_3R_301()) { jj_scanpos = xsp; break; }
9191 }
9192 return false;
9193 }
9194
9195 final private boolean jj_3R_284() {
9196 if (jj_3R_53()) return true;
9197 return false;
9198 }
9199
9200 final private boolean jj_3R_51() {
9201 if (jj_3R_53()) return true;
9202 return false;
9203 }
9204
9205 final private boolean jj_3_91() {
9206 if (jj_3R_67()) return true;
9207 return false;
9208 }
9209
9210 final private boolean jj_3R_316() {
9211 if (jj_3R_95()) return true;
9212 return false;
9213 }
9214
9215 final private boolean jj_3R_223() {
9216 if (jj_3R_68()) return true;
9217 return false;
9218 }
9219
9220 final private boolean jj_3R_315() {
9221 if (jj_3R_354()) return true;
9222 return false;
9223 }
9224
9225 final private boolean jj_3_23() {
9226 if (jj_3R_46()) return true;
9227 return false;
9228 }
9229
9230 final private boolean jj_3R_127() {
9231 Token xsp;
9232 xsp = jj_scanpos;
9233 if (jj_3R_223()) jj_scanpos = xsp;
9234 xsp = jj_scanpos;
9235 if (jj_scan_token(99)) jj_scanpos = xsp;
9236 if (jj_scan_token(ID)) return true;
9237 xsp = jj_scanpos;
9238 if (jj_3R_224()) jj_scanpos = xsp;
9239 return false;
9240 }
9241
9242 final private boolean jj_3R_261() {
9243 if (jj_3R_53()) return true;
9244 return false;
9245 }
9246
9247 final private boolean jj_3R_314() {
9248 if (jj_scan_token(LPARENTHESIS)) return true;
9249 if (jj_3R_75()) return true;
9250 if (jj_scan_token(RPARENTHESIS)) return true;
9251 return false;
9252 }
9253
9254 final private boolean jj_3R_283() {
9255 if (jj_3R_53()) return true;
9256 return false;
9257 }
9258
9259 final private boolean jj_3R_186() {
9260 if (jj_scan_token(OPERATOR)) return true;
9261 if (jj_3R_93()) return true;
9262 return false;
9263 }
9264
9265 final private boolean jj_3R_249() {
9266 Token xsp;
9267 xsp = jj_scanpos;
9268 if (jj_scan_token(16)) jj_scanpos = xsp;
9269 if (jj_scan_token(NEW)) return true;
9270 xsp = jj_scanpos;
9271 if (jj_3R_313()) jj_scanpos = xsp;
9272 xsp = jj_scanpos;
9273 if (jj_3R_314()) {
9274 jj_scanpos = xsp;
9275 if (jj_3R_315()) return true;
9276 }
9277 xsp = jj_scanpos;
9278 if (jj_3R_316()) jj_scanpos = xsp;
9279 return false;
9280 }
9281
9282 final private boolean jj_3R_185() {
9283 if (jj_scan_token(ID)) return true;
9284 Token xsp;
9285 xsp = jj_scanpos;
9286 if (jj_3R_261()) jj_scanpos = xsp;
9287 return false;
9288 }
9289
9290 final private boolean jj_3_93() {
9291 if (jj_3R_75()) return true;
9292 if (jj_scan_token(RPARENTHESIS)) return true;
9293 return false;
9294 }
9295
9296 final private boolean jj_3R_387() {
9297 if (jj_3R_183()) return true;
9298 return false;
9299 }
9300
9301 final private boolean jj_3_22() {
9302 Token xsp;
9303 xsp = jj_scanpos;
9304 if (jj_scan_token(99)) jj_scanpos = xsp;
9305 if (jj_scan_token(ID)) return true;
9306 xsp = jj_scanpos;
9307 if (jj_3R_52()) jj_scanpos = xsp;
9308 if (jj_scan_token(SCOPE)) return true;
9309 return false;
9310 }
9311
9312 final private boolean jj_3R_184() {
9313 if (jj_3R_68()) return true;
9314 return false;
9315 }
9316
9317 final private boolean jj_3R_102() {
9318 Token xsp;
9319 xsp = jj_scanpos;
9320 if (jj_3R_184()) jj_scanpos = xsp;
9321 xsp = jj_scanpos;
9322 if (jj_3R_185()) {
9323 jj_scanpos = xsp;
9324 if (jj_3R_186()) return true;
9325 }
9326 return false;
9327 }
9328
9329 final private boolean jj_3R_170() {
9330 if (jj_3R_253()) return true;
9331 return false;
9332 }
9333
9334 final private boolean jj_3R_169() {
9335 if (jj_3R_162()) return true;
9336 return false;
9337 }
9338
9339 final private boolean jj_3_95() {
9340 Token xsp;
9341 xsp = jj_scanpos;
9342 if (jj_scan_token(16)) jj_scanpos = xsp;
9343 if (jj_scan_token(DELETE)) return true;
9344 return false;
9345 }
9346
9347 final private boolean jj_3R_252() {
9348 if (jj_3R_78()) return true;
9349 if (jj_scan_token(RPARENTHESIS)) return true;
9350 return false;
9351 }
9352
9353 final private boolean jj_3_21() {
9354 Token xsp;
9355 xsp = jj_scanpos;
9356 if (jj_scan_token(99)) jj_scanpos = xsp;
9357 if (jj_scan_token(ID)) return true;
9358 xsp = jj_scanpos;
9359 if (jj_3R_51()) jj_scanpos = xsp;
9360 if (jj_scan_token(SCOPE)) return true;
9361 return false;
9362 }
9363
9364 final private boolean jj_3_94() {
9365 Token xsp;
9366 xsp = jj_scanpos;
9367 if (jj_scan_token(16)) jj_scanpos = xsp;
9368 if (jj_scan_token(NEW)) return true;
9369 return false;
9370 }
9371
9372 final private boolean jj_3R_251() {
9373 if (jj_3R_75()) return true;
9374 if (jj_scan_token(RPARENTHESIS)) return true;
9375 return false;
9376 }
9377
9378 final private boolean jj_3_90() {
9379 if (jj_3R_53()) return true;
9380 return false;
9381 }
9382
9383 final private boolean jj_3R_226() {
9384 Token xsp;
9385 xsp = jj_scanpos;
9386 if (jj_scan_token(99)) jj_scanpos = xsp;
9387 if (jj_scan_token(ID)) return true;
9388 xsp = jj_scanpos;
9389 if (jj_3R_284()) jj_scanpos = xsp;
9390 if (jj_scan_token(SCOPE)) return true;
9391 return false;
9392 }
9393
9394 final private boolean jj_3R_208() {
9395 if (jj_3R_53()) return true;
9396 return false;
9397 }
9398
9399 final private boolean jj_3R_168() {
9400 if (jj_scan_token(TYPEID)) return true;
9401 if (jj_scan_token(LPARENTHESIS)) return true;
9402 Token xsp;
9403 xsp = jj_scanpos;
9404 if (jj_3R_251()) {
9405 jj_scanpos = xsp;
9406 if (jj_3R_252()) return true;
9407 }
9408 return false;
9409 }
9410
9411 final private boolean jj_3R_132() {
9412 Token xsp;
9413 if (jj_3R_226()) return true;
9414 while (true) {
9415 xsp = jj_scanpos;
9416 if (jj_3R_226()) { jj_scanpos = xsp; break; }
9417 }
9418 return false;
9419 }
9420
9421 final private boolean jj_3R_167() {
9422 if (jj_3R_250()) return true;
9423 return false;
9424 }
9425
9426 final private boolean jj_3R_225() {
9427 Token xsp;
9428 xsp = jj_scanpos;
9429 if (jj_scan_token(99)) jj_scanpos = xsp;
9430 if (jj_scan_token(ID)) return true;
9431 xsp = jj_scanpos;
9432 if (jj_3R_283()) jj_scanpos = xsp;
9433 if (jj_scan_token(SCOPE)) return true;
9434 return false;
9435 }
9436
9437 final private boolean jj_3R_166() {
9438 if (jj_3R_249()) return true;
9439 return false;
9440 }
9441
9442 final private boolean jj_3R_386() {
9443 if (jj_3R_53()) return true;
9444 return false;
9445 }
9446
9447 final private boolean jj_3R_165() {
9448 if (jj_scan_token(LPARENTHESIS)) return true;
9449 if (jj_3R_78()) return true;
9450 if (jj_scan_token(RPARENTHESIS)) return true;
9451 return false;
9452 }
9453
9454 final private boolean jj_3_92() {
9455 if (jj_scan_token(STRING)) return true;
9456 return false;
9457 }
9458
9459 final private boolean jj_3R_131() {
9460 if (jj_scan_token(SCOPE)) return true;
9461 Token xsp;
9462 while (true) {
9463 xsp = jj_scanpos;
9464 if (jj_3R_225()) { jj_scanpos = xsp; break; }
9465 }
9466 return false;
9467 }
9468
9469 final private boolean jj_3R_164() {
9470 Token xsp;
9471 if (jj_3_92()) return true;
9472 while (true) {
9473 xsp = jj_scanpos;
9474 if (jj_3_92()) { jj_scanpos = xsp; break; }
9475 }
9476 return false;
9477 }
9478
9479 final private boolean jj_3R_92() {
9480 Token xsp;
9481 xsp = jj_scanpos;
9482 if (jj_3R_163()) {
9483 jj_scanpos = xsp;
9484 if (jj_3R_164()) {
9485 jj_scanpos = xsp;
9486 if (jj_3R_165()) {
9487 jj_scanpos = xsp;
9488 if (jj_3R_166()) {
9489 jj_scanpos = xsp;
9490 if (jj_3R_167()) {
9491 jj_scanpos = xsp;
9492 if (jj_3R_168()) {
9493 jj_scanpos = xsp;
9494 if (jj_3R_169()) {
9495 jj_scanpos = xsp;
9496 if (jj_3R_170()) return true;
9497 }
9498 }
9499 }
9500 }
9501 }
9502 }
9503 }
9504 return false;
9505 }
9506
9507 final private boolean jj_3R_163() {
9508 if (jj_scan_token(THIS)) return true;
9509 return false;
9510 }
9511
9512 final private boolean jj_3R_68() {
9513 Token xsp;
9514 xsp = jj_scanpos;
9515 if (jj_3R_131()) {
9516 jj_scanpos = xsp;
9517 if (jj_3R_132()) return true;
9518 }
9519 return false;
9520 }
9521
9522 final private boolean jj_3R_117() {
9523 Token xsp;
9524 xsp = jj_scanpos;
9525 if (jj_scan_token(99)) jj_scanpos = xsp;
9526 if (jj_scan_token(ID)) return true;
9527 xsp = jj_scanpos;
9528 if (jj_3R_208()) jj_scanpos = xsp;
9529 if (jj_scan_token(SCOPE)) return true;
9530 return false;
9531 }
9532
9533 final private boolean jj_3R_69() {
9534 if (jj_scan_token(ID)) return true;
9535 if (jj_3R_53()) return true;
9536 return false;
9537 }
9538
9539 final private boolean jj_3R_46() {
9540 Token xsp;
9541 xsp = jj_scanpos;
9542 if (jj_scan_token(16)) {
9543 jj_scanpos = xsp;
9544 if (jj_3R_117()) return true;
9545 }
9546 return false;
9547 }
9548
9549 final private boolean jj_3R_203() {
9550 if (jj_3R_127()) return true;
9551 return false;
9552 }
9553
9554 final private boolean jj_3R_353() {
9555 if (jj_scan_token(OPERATOR)) return true;
9556 if (jj_3R_44()) return true;
9557 Token xsp;
9558 xsp = jj_scanpos;
9559 if (jj_3R_387()) jj_scanpos = xsp;
9560 return false;
9561 }
9562
9563 final private boolean jj_3R_267() {
9564 if (jj_3R_127()) return true;
9565 return false;
9566 }
9567
9568 final private boolean jj_3R_50() {
9569 Token xsp;
9570 xsp = jj_scanpos;
9571 if (jj_scan_token(109)) {
9572 jj_scanpos = xsp;
9573 if (jj_scan_token(64)) {
9574 jj_scanpos = xsp;
9575 if (jj_scan_token(111)) {
9576 jj_scanpos = xsp;
9577 if (jj_scan_token(92)) {
9578 jj_scanpos = xsp;
9579 if (jj_scan_token(81)) {
9580 jj_scanpos = xsp;
9581 if (jj_scan_token(82)) {
9582 jj_scanpos = xsp;
9583 if (jj_scan_token(75)) {
9584 jj_scanpos = xsp;
9585 if (jj_scan_token(70)) {
9586 jj_scanpos = xsp;
9587 if (jj_scan_token(60)) {
9588 jj_scanpos = xsp;
9589 if (jj_scan_token(93)) {
9590 jj_scanpos = xsp;
9591 if (jj_scan_token(106)) return true;
9592 }
9593 }
9594 }
9595 }
9596 }
9597 }
9598 }
9599 }
9600 }
9601 }
9602 return false;
9603 }
9604
9605 final private boolean jj_3_89() {
9606 if (jj_scan_token(OPERATOR)) return true;
9607 if (jj_3R_93()) return true;
9608 return false;
9609 }
9610
9611 final private boolean jj_3R_352() {
9612 if (jj_scan_token(OPERATOR)) return true;
9613 if (jj_3R_93()) return true;
9614 Token xsp;
9615 xsp = jj_scanpos;
9616 if (jj_3R_386()) jj_scanpos = xsp;
9617 return false;
9618 }
9619
9620 final private boolean jj_3_88() {
9621 Token xsp;
9622 xsp = jj_scanpos;
9623 if (jj_scan_token(53)) jj_scanpos = xsp;
9624 if (jj_3R_69()) return true;
9625 return false;
9626 }
9627
9628 final private boolean jj_3R_385() {
9629 if (jj_3R_175()) return true;
9630 return false;
9631 }
9632
9633 final private boolean jj_3R_218() {
9634 Token xsp;
9635 xsp = jj_scanpos;
9636 if (jj_scan_token(65)) {
9637 jj_scanpos = xsp;
9638 if (jj_scan_token(110)) {
9639 jj_scanpos = xsp;
9640 if (jj_scan_token(104)) {
9641 jj_scanpos = xsp;
9642 if (jj_scan_token(83)) return true;
9643 }
9644 }
9645 }
9646 return false;
9647 }
9648
9649 final private boolean jj_3R_312() {
9650 Token xsp;
9651 xsp = jj_scanpos;
9652 if (jj_scan_token(53)) jj_scanpos = xsp;
9653 if (jj_scan_token(ID)) return true;
9654 return false;
9655 }
9656
9657 final private boolean jj_3_85() {
9658 if (jj_scan_token(TEMPLATE)) return true;
9659 return false;
9660 }
9661
9662 final private boolean jj_3R_311() {
9663 if (jj_3R_353()) return true;
9664 return false;
9665 }
9666
9667 final private boolean jj_3_87() {
9668 if (jj_3R_46()) return true;
9669 return false;
9670 }
9671
9672 final private boolean jj_3R_310() {
9673 if (jj_3R_352()) return true;
9674 return false;
9675 }
9676
9677 final private boolean jj_3R_202() {
9678 if (jj_3R_269()) return true;
9679 return false;
9680 }
9681
9682 final private boolean jj_3R_217() {
9683 Token xsp;
9684 xsp = jj_scanpos;
9685 if (jj_scan_token(59)) {
9686 jj_scanpos = xsp;
9687 if (jj_scan_token(90)) {
9688 jj_scanpos = xsp;
9689 if (jj_scan_token(95)) {
9690 jj_scanpos = xsp;
9691 if (jj_scan_token(74)) {
9692 jj_scanpos = xsp;
9693 if (jj_scan_token(102)) return true;
9694 }
9695 }
9696 }
9697 }
9698 return false;
9699 }
9700
9701 final private boolean jj_3R_309() {
9702 Token xsp;
9703 xsp = jj_scanpos;
9704 if (jj_scan_token(53)) jj_scanpos = xsp;
9705 if (jj_3R_69()) return true;
9706 return false;
9707 }
9708
9709 final private boolean jj_3R_248() {
9710 Token xsp;
9711 xsp = jj_scanpos;
9712 if (jj_3R_309()) {
9713 jj_scanpos = xsp;
9714 if (jj_3R_310()) {
9715 jj_scanpos = xsp;
9716 if (jj_3R_311()) {
9717 jj_scanpos = xsp;
9718 if (jj_3R_312()) return true;
9719 }
9720 }
9721 }
9722 return false;
9723 }
9724
9725 final private boolean jj_3R_266() {
9726 if (jj_3R_269()) return true;
9727 return false;
9728 }
9729
9730 final private boolean jj_3R_247() {
9731 if (jj_3R_68()) return true;
9732 return false;
9733 }
9734
9735 final private boolean jj_3R_162() {
9736 Token xsp;
9737 xsp = jj_scanpos;
9738 if (jj_3R_247()) jj_scanpos = xsp;
9739 if (jj_3R_248()) return true;
9740 return false;
9741 }
9742
9743 final private boolean jj_3_20() {
9744 if (jj_3R_49()) return true;
9745 return false;
9746 }
9747
9748 final private boolean jj_3R_116() {
9749 if (jj_3R_126()) return true;
9750 return false;
9751 }
9752
9753 final private boolean jj_3R_120() {
9754 if (jj_3R_218()) return true;
9755 return false;
9756 }
9757
9758 final private boolean jj_3R_49() {
9759 Token xsp;
9760 xsp = jj_scanpos;
9761 if (jj_3R_119()) {
9762 jj_scanpos = xsp;
9763 if (jj_3R_120()) {
9764 jj_scanpos = xsp;
9765 if (jj_scan_token(80)) {
9766 jj_scanpos = xsp;
9767 if (jj_scan_token(108)) {
9768 jj_scanpos = xsp;
9769 if (jj_scan_token(77)) return true;
9770 }
9771 }
9772 }
9773 }
9774 return false;
9775 }
9776
9777 final private boolean jj_3_19() {
9778 if (jj_3R_49()) return true;
9779 return false;
9780 }
9781
9782 final private boolean jj_3R_119() {
9783 if (jj_3R_217()) return true;
9784 return false;
9785 }
9786
9787 final private boolean jj_3_18() {
9788 if (jj_3R_50()) return true;
9789 return false;
9790 }
9791
9792 final private boolean jj_3R_374() {
9793 if (jj_3R_127()) return true;
9794 if (jj_scan_token(LPARENTHESIS)) return true;
9795 Token xsp;
9796 xsp = jj_scanpos;
9797 if (jj_3R_385()) jj_scanpos = xsp;
9798 if (jj_scan_token(RPARENTHESIS)) return true;
9799 return false;
9800 }
9801
9802 final private boolean jj_3_17() {
9803 if (jj_3R_49()) return true;
9804 return false;
9805 }
9806
9807 final private boolean jj_3_13() {
9808 if (jj_3R_46()) return true;
9809 return false;
9810 }
9811
9812 final private boolean jj_3R_91() {
9813 if (jj_scan_token(MINUSMINUS)) return true;
9814 return false;
9815 }
9816
9817 final private boolean jj_3R_161() {
9818 if (jj_3R_175()) return true;
9819 return false;
9820 }
9821
9822 final private boolean jj_3_16() {
9823 if (jj_3R_50()) return true;
9824 return false;
9825 }
9826
9827 final private boolean jj_3R_90() {
9828 if (jj_scan_token(PLUSPLUS)) return true;
9829 return false;
9830 }
9831
9832 final private boolean jj_3R_204() {
9833 if (jj_3R_49()) return true;
9834 return false;
9835 }
9836
9837 final private boolean jj_3R_201() {
9838 if (jj_3R_268()) return true;
9839 return false;
9840 }
9841
9842 final private boolean jj_3R_89() {
9843 Token xsp;
9844 xsp = jj_scanpos;
9845 if (jj_scan_token(55)) {
9846 jj_scanpos = xsp;
9847 if (jj_scan_token(56)) return true;
9848 }
9849 xsp = jj_scanpos;
9850 if (jj_scan_token(99)) jj_scanpos = xsp;
9851 if (jj_3R_162()) return true;
9852 return false;
9853 }
9854
9855 final private boolean jj_3_15() {
9856 if (jj_3R_49()) return true;
9857 return false;
9858 }
9859
9860 final private boolean jj_3R_110() {
9861 Token xsp;
9862 xsp = jj_scanpos;
9863 if (jj_3R_201()) {
9864 jj_scanpos = xsp;
9865 if (jj_3R_202()) {
9866 jj_scanpos = xsp;
9867 if (jj_3R_203()) return true;
9868 }
9869 }
9870 while (true) {
9871 xsp = jj_scanpos;
9872 if (jj_3R_204()) { jj_scanpos = xsp; break; }
9873 }
9874 return false;
9875 }
9876
9877 final private boolean jj_3_86() {
9878 if (jj_3R_92()) return true;
9879 return false;
9880 }
9881
9882 final private boolean jj_3R_200() {
9883 if (jj_3R_49()) return true;
9884 return false;
9885 }
9886
9887 final private boolean jj_3R_88() {
9888 if (jj_scan_token(LPARENTHESIS)) return true;
9889 Token xsp;
9890 xsp = jj_scanpos;
9891 if (jj_3R_161()) jj_scanpos = xsp;
9892 if (jj_scan_token(RPARENTHESIS)) return true;
9893 return false;
9894 }
9895
9896 final private boolean jj_3R_199() {
9897 if (jj_3R_50()) return true;
9898 return false;
9899 }
9900
9901 final private boolean jj_3R_109() {
9902 Token xsp;
9903 if (jj_3R_199()) return true;
9904 while (true) {
9905 xsp = jj_scanpos;
9906 if (jj_3R_199()) { jj_scanpos = xsp; break; }
9907 }
9908 while (true) {
9909 xsp = jj_scanpos;
9910 if (jj_3R_200()) { jj_scanpos = xsp; break; }
9911 }
9912 return false;
9913 }
9914
9915 final private boolean jj_3R_87() {
9916 if (jj_scan_token(LSQUAREBRACKET)) return true;
9917 if (jj_3R_78()) return true;
9918 if (jj_scan_token(RSQUAREBRACKET)) return true;
9919 return false;
9920 }
9921
9922 final private boolean jj_3R_198() {
9923 if (jj_3R_49()) return true;
9924 return false;
9925 }
9926
9927 final private boolean jj_3R_265() {
9928 if (jj_3R_268()) return true;
9929 return false;
9930 }
9931
9932 final private boolean jj_3R_47() {
9933 if (jj_scan_token(ID)) return true;
9934 return false;
9935 }
9936
9937 final private boolean jj_3R_197() {
9938 Token xsp;
9939 xsp = jj_scanpos;
9940 if (jj_3R_265()) {
9941 jj_scanpos = xsp;
9942 if (jj_3R_266()) {
9943 jj_scanpos = xsp;
9944 if (jj_3R_267()) return true;
9945 }
9946 }
9947 return false;
9948 }
9949
9950 final private boolean jj_3R_264() {
9951 if (jj_3R_50()) return true;
9952 return false;
9953 }
9954
9955 final private boolean jj_3_84() {
9956 Token xsp;
9957 xsp = jj_scanpos;
9958 if (jj_3R_87()) {
9959 jj_scanpos = xsp;
9960 if (jj_3R_88()) {
9961 jj_scanpos = xsp;
9962 if (jj_3R_89()) {
9963 jj_scanpos = xsp;
9964 if (jj_3R_90()) {
9965 jj_scanpos = xsp;
9966 if (jj_3R_91()) return true;
9967 }
9968 }
9969 }
9970 }
9971 return false;
9972 }
9973
9974 final private boolean jj_3R_115() {
9975 if (jj_3R_182()) return true;
9976 return false;
9977 }
9978
9979 final private boolean jj_3R_196() {
9980 Token xsp;
9981 if (jj_3R_264()) return true;
9982 while (true) {
9983 xsp = jj_scanpos;
9984 if (jj_3R_264()) { jj_scanpos = xsp; break; }
9985 }
9986 return false;
9987 }
9988
9989 final private boolean jj_3R_270() {
9990 if (jj_scan_token(STAR)) return true;
9991 if (jj_3R_114()) return true;
9992 return false;
9993 }
9994
9995 final private boolean jj_3R_245() {
9996 if (jj_3R_50()) return true;
9997 return false;
9998 }
9999
10000 final private boolean jj_3R_206() {
10001 Token xsp;
10002 xsp = jj_scanpos;
10003 if (jj_3R_270()) {
10004 jj_scanpos = xsp;
10005 if (jj_scan_token(37)) return true;
10006 }
10007 return false;
10008 }
10009
10010 final private boolean jj_3R_373() {
10011 if (jj_3R_92()) return true;
10012 Token xsp;
10013 while (true) {
10014 xsp = jj_scanpos;
10015 if (jj_3_84()) { jj_scanpos = xsp; break; }
10016 }
10017 return false;
10018 }
10019
10020 final private boolean jj_3R_351() {
10021 Token xsp;
10022 xsp = jj_scanpos;
10023 if (jj_3R_373()) {
10024 jj_scanpos = xsp;
10025 if (jj_3R_374()) return true;
10026 }
10027 return false;
10028 }
10029
10030 final private boolean jj_3R_195() {
10031 if (jj_3R_49()) return true;
10032 return false;
10033 }
10034
10035 final private boolean jj_3R_44() {
10036 Token xsp;
10037 xsp = jj_scanpos;
10038 if (jj_3R_108()) {
10039 jj_scanpos = xsp;
10040 if (jj_3R_109()) {
10041 jj_scanpos = xsp;
10042 if (jj_3R_110()) return true;
10043 }
10044 }
10045 return false;
10046 }
10047
10048 final private boolean jj_3R_108() {
10049 Token xsp;
10050 if (jj_3R_195()) return true;
10051 while (true) {
10052 xsp = jj_scanpos;
10053 if (jj_3R_195()) { jj_scanpos = xsp; break; }
10054 }
10055 xsp = jj_scanpos;
10056 if (jj_3R_196()) {
10057 jj_scanpos = xsp;
10058 if (jj_3R_197()) return true;
10059 }
10060 while (true) {
10061 xsp = jj_scanpos;
10062 if (jj_3R_198()) { jj_scanpos = xsp; break; }
10063 }
10064 return false;
10065 }
10066
10067 final private boolean jj_3R_48() {
10068 if (jj_3R_118()) return true;
10069 return false;
10070 }
10071
10072 final private boolean jj_3_82() {
10073 if (jj_scan_token(LPARENTHESIS)) return true;
10074 if (jj_3R_75()) return true;
10075 if (jj_scan_token(RPARENTHESIS)) return true;
10076 return false;
10077 }
10078
10079 final private boolean jj_3R_86() {
10080 Token xsp;
10081 xsp = jj_scanpos;
10082 if (jj_scan_token(37)) {
10083 jj_scanpos = xsp;
10084 if (jj_scan_token(48)) {
10085 jj_scanpos = xsp;
10086 if (jj_scan_token(46)) {
10087 jj_scanpos = xsp;
10088 if (jj_scan_token(47)) {
10089 jj_scanpos = xsp;
10090 if (jj_scan_token(53)) {
10091 jj_scanpos = xsp;
10092 if (jj_scan_token(54)) return true;
10093 }
10094 }
10095 }
10096 }
10097 }
10098 return false;
10099 }
10100
10101 final private boolean jj_3_11() {
10102 if (jj_scan_token(SEMICOLON)) return true;
10103 return false;
10104 }
10105
10106 final private boolean jj_3_14() {
10107 Token xsp;
10108 xsp = jj_scanpos;
10109 if (jj_3R_47()) jj_scanpos = xsp;
10110 if (jj_scan_token(LCURLYBRACE)) return true;
10111 while (true) {
10112 xsp = jj_scanpos;
10113 if (jj_3R_48()) { jj_scanpos = xsp; break; }
10114 }
10115 if (jj_scan_token(RCURLYBRACE)) return true;
10116 return false;
10117 }
10118
10119 final private boolean jj_3R_308() {
10120 if (jj_3R_351()) return true;
10121 return false;
10122 }
10123
10124 final private boolean jj_3R_350() {
10125 if (jj_3R_246()) return true;
10126 return false;
10127 }
10128
10129 final private boolean jj_3R_277() {
10130 if (jj_scan_token(NAMESPACE)) return true;
10131 return false;
10132 }
10133
10134 final private boolean jj_3R_349() {
10135 if (jj_scan_token(LPARENTHESIS)) return true;
10136 if (jj_3R_75()) return true;
10137 if (jj_scan_token(RPARENTHESIS)) return true;
10138 return false;
10139 }
10140
10141 final private boolean jj_3R_307() {
10142 if (jj_scan_token(SIZEOF)) return true;
10143 Token xsp;
10144 xsp = jj_scanpos;
10145 if (jj_3R_349()) {
10146 jj_scanpos = xsp;
10147 if (jj_3R_350()) return true;
10148 }
10149 return false;
10150 }
10151
10152 final private boolean jj_3_12() {
10153 if (jj_3R_46()) return true;
10154 return false;
10155 }
10156
10157 final private boolean jj_3R_194() {
10158 if (jj_scan_token(USING)) return true;
10159 if (jj_3R_127()) return true;
10160 if (jj_scan_token(SEMICOLON)) return true;
10161 return false;
10162 }
10163
10164 final private boolean jj_3_83() {
10165 if (jj_3R_86()) return true;
10166 if (jj_3R_85()) return true;
10167 return false;
10168 }
10169
10170 final private boolean jj_3R_391() {
10171 Token xsp;
10172 xsp = jj_scanpos;
10173 if (jj_scan_token(57)) {
10174 jj_scanpos = xsp;
10175 if (jj_scan_token(58)) return true;
10176 }
10177 if (jj_3R_157()) return true;
10178 return false;
10179 }
10180
10181 final private boolean jj_3R_306() {
10182 if (jj_scan_token(MINUSMINUS)) return true;
10183 if (jj_3R_85()) return true;
10184 return false;
10185 }
10186
10187 final private boolean jj_3_81() {
10188 if (jj_3R_50()) return true;
10189 return false;
10190 }
10191
10192 final private boolean jj_3R_305() {
10193 if (jj_scan_token(PLUSPLUS)) return true;
10194 if (jj_3R_85()) return true;
10195 return false;
10196 }
10197
10198 final private boolean jj_3R_246() {
10199 Token xsp;
10200 xsp = jj_scanpos;
10201 if (jj_3R_305()) {
10202 jj_scanpos = xsp;
10203 if (jj_3R_306()) {
10204 jj_scanpos = xsp;
10205 if (jj_3_83()) {
10206 jj_scanpos = xsp;
10207 if (jj_3R_307()) {
10208 jj_scanpos = xsp;
10209 if (jj_3R_308()) return true;
10210 }
10211 }
10212 }
10213 }
10214 return false;
10215 }
10216
10217 final private boolean jj_3_80() {
10218 if (jj_scan_token(LPARENTHESIS)) return true;
10219 if (jj_3R_75()) return true;
10220 if (jj_scan_token(RPARENTHESIS)) return true;
10221 if (jj_3R_85()) return true;
10222 return false;
10223 }
10224
10225 final private boolean jj_3_78() {
10226 Token xsp;
10227 xsp = jj_scanpos;
10228 if (jj_scan_token(46)) {
10229 jj_scanpos = xsp;
10230 if (jj_scan_token(47)) return true;
10231 }
10232 if (jj_3R_83()) return true;
10233 return false;
10234 }
10235
10236 final private boolean jj_3R_360() {
10237 if (jj_scan_token(COMMA)) return true;
10238 if (jj_scan_token(ELLIPSIS)) return true;
10239 return false;
10240 }
10241
10242 final private boolean jj_3R_263() {
10243 if (jj_3R_68()) return true;
10244 return false;
10245 }
10246
10247 final private boolean jj_3R_193() {
10248 if (jj_scan_token(USING)) return true;
10249 if (jj_scan_token(NAMESPACE)) return true;
10250 Token xsp;
10251 xsp = jj_scanpos;
10252 if (jj_3R_263()) jj_scanpos = xsp;
10253 if (jj_scan_token(ID)) return true;
10254 if (jj_scan_token(SEMICOLON)) return true;
10255 return false;
10256 }
10257
10258 final private boolean jj_3R_160() {
10259 if (jj_3R_246()) return true;
10260 return false;
10261 }
10262
10263 final private boolean jj_3_79() {
10264 Token xsp;
10265 xsp = jj_scanpos;
10266 if (jj_scan_token(48)) {
10267 jj_scanpos = xsp;
10268 if (jj_scan_token(49)) {
10269 jj_scanpos = xsp;
10270 if (jj_scan_token(50)) return true;
10271 }
10272 }
10273 if (jj_3R_84()) return true;
10274 return false;
10275 }
10276
10277 final private boolean jj_3R_159() {
10278 Token xsp;
10279 if (jj_3R_245()) return true;
10280 while (true) {
10281 xsp = jj_scanpos;
10282 if (jj_3R_245()) { jj_scanpos = xsp; break; }
10283 }
10284 if (jj_scan_token(LPARENTHESIS)) return true;
10285 if (jj_3R_80()) return true;
10286 if (jj_scan_token(RPARENTHESIS)) return true;
10287 return false;
10288 }
10289
10290 final private boolean jj_3R_415() {
10291 Token xsp;
10292 xsp = jj_scanpos;
10293 if (jj_scan_token(44)) {
10294 jj_scanpos = xsp;
10295 if (jj_scan_token(45)) return true;
10296 }
10297 if (jj_3R_156()) return true;
10298 return false;
10299 }
10300
10301 final private boolean jj_3R_85() {
10302 Token xsp;
10303 xsp = jj_scanpos;
10304 if (jj_3R_158()) {
10305 jj_scanpos = xsp;
10306 if (jj_3R_159()) {
10307 jj_scanpos = xsp;
10308 if (jj_3R_160()) return true;
10309 }
10310 }
10311 return false;
10312 }
10313
10314 final private boolean jj_3R_158() {
10315 if (jj_scan_token(LPARENTHESIS)) return true;
10316 if (jj_3R_75()) return true;
10317 if (jj_scan_token(RPARENTHESIS)) return true;
10318 if (jj_3R_85()) return true;
10319 return false;
10320 }
10321
10322 final private boolean jj_3R_157() {
10323 if (jj_3R_85()) return true;
10324 Token xsp;
10325 xsp = jj_scanpos;
10326 if (jj_3R_391()) jj_scanpos = xsp;
10327 return false;
10328 }
10329
10330 final private boolean jj_3R_278() {
10331 if (jj_scan_token(EXTERN)) return true;
10332 return false;
10333 }
10334
10335 final private boolean jj_3_77() {
10336 Token xsp;
10337 xsp = jj_scanpos;
10338 if (jj_scan_token(40)) {
10339 jj_scanpos = xsp;
10340 if (jj_scan_token(41)) {
10341 jj_scanpos = xsp;
10342 if (jj_scan_token(42)) {
10343 jj_scanpos = xsp;
10344 if (jj_scan_token(43)) return true;
10345 }
10346 }
10347 }
10348 if (jj_3R_82()) return true;
10349 return false;
10350 }
10351
10352 final private boolean jj_3R_398() {
10353 Token xsp;
10354 xsp = jj_scanpos;
10355 if (jj_scan_token(39)) {
10356 jj_scanpos = xsp;
10357 if (jj_scan_token(38)) return true;
10358 }
10359 if (jj_3R_155()) return true;
10360 return false;
10361 }
10362
10363 final private boolean jj_3R_84() {
10364 if (jj_3R_157()) return true;
10365 Token xsp;
10366 xsp = jj_scanpos;
10367 if (jj_3_79()) jj_scanpos = xsp;
10368 return false;
10369 }
10370
10371 final private boolean jj_3R_205() {
10372 if (jj_3R_68()) return true;
10373 return false;
10374 }
10375
10376 final private boolean jj_3R_112() {
10377 Token xsp;
10378 xsp = jj_scanpos;
10379 if (jj_3R_205()) jj_scanpos = xsp;
10380 if (jj_scan_token(OPERATOR)) return true;
10381 if (jj_3R_44()) return true;
10382 xsp = jj_scanpos;
10383 if (jj_3R_206()) jj_scanpos = xsp;
10384 return false;
10385 }
10386
10387 final private boolean jj_3R_83() {
10388 if (jj_3R_84()) return true;
10389 Token xsp;
10390 xsp = jj_scanpos;
10391 if (jj_3_78()) jj_scanpos = xsp;
10392 return false;
10393 }
10394
10395 final private boolean jj_3_76() {
10396 if (jj_scan_token(AMPERSAND)) return true;
10397 if (jj_3R_81()) return true;
10398 return false;
10399 }
10400
10401 final private boolean jj_3R_326() {
10402 if (jj_3R_359()) return true;
10403 Token xsp;
10404 xsp = jj_scanpos;
10405 if (jj_3R_360()) jj_scanpos = xsp;
10406 return false;
10407 }
10408
10409 final private boolean jj_3R_271() {
10410 Token xsp;
10411 xsp = jj_scanpos;
10412 if (jj_3R_326()) {
10413 jj_scanpos = xsp;
10414 if (jj_scan_token(21)) return true;
10415 }
10416 return false;
10417 }
10418
10419 final private boolean jj_3R_156() {
10420 if (jj_3R_83()) return true;
10421 Token xsp;
10422 xsp = jj_scanpos;
10423 if (jj_3R_415()) jj_scanpos = xsp;
10424 return false;
10425 }
10426
10427 final private boolean jj_3R_207() {
10428 if (jj_3R_271()) return true;
10429 return false;
10430 }
10431
10432 final private boolean jj_3R_384() {
10433 if (jj_scan_token(BITWISEOR)) return true;
10434 if (jj_3R_371()) return true;
10435 return false;
10436 }
10437
10438 final private boolean jj_3R_392() {
10439 if (jj_scan_token(BITWISEXOR)) return true;
10440 if (jj_3R_383()) return true;
10441 return false;
10442 }
10443
10444 final private boolean jj_3R_113() {
10445 if (jj_scan_token(LPARENTHESIS)) return true;
10446 Token xsp;
10447 xsp = jj_scanpos;
10448 if (jj_3R_207()) jj_scanpos = xsp;
10449 if (jj_scan_token(RPARENTHESIS)) return true;
10450 return false;
10451 }
10452
10453 final private boolean jj_3R_82() {
10454 if (jj_3R_156()) return true;
10455 Token xsp;
10456 xsp = jj_scanpos;
10457 if (jj_3_77()) jj_scanpos = xsp;
10458 return false;
10459 }
10460
10461 final private boolean jj_3_10() {
10462 if (jj_3R_45()) return true;
10463 if (jj_scan_token(SEMICOLON)) return true;
10464 return false;
10465 }
10466
10467 final private boolean jj_3R_372() {
10468 if (jj_scan_token(AND)) return true;
10469 if (jj_3R_347()) return true;
10470 return false;
10471 }
10472
10473 final private boolean jj_3R_111() {
10474 if (jj_3R_49()) return true;
10475 return false;
10476 }
10477
10478 final private boolean jj_3R_45() {
10479 Token xsp;
10480 while (true) {
10481 xsp = jj_scanpos;
10482 if (jj_3R_111()) { jj_scanpos = xsp; break; }
10483 }
10484 if (jj_3R_112()) return true;
10485 if (jj_3R_113()) return true;
10486 if (jj_3R_114()) return true;
10487 xsp = jj_scanpos;
10488 if (jj_3R_115()) jj_scanpos = xsp;
10489 xsp = jj_scanpos;
10490 if (jj_3R_116()) jj_scanpos = xsp;
10491 return false;
10492 }
10493
10494 final private boolean jj_3R_155() {
10495 if (jj_3R_82()) return true;
10496 Token xsp;
10497 xsp = jj_scanpos;
10498 if (jj_3R_398()) jj_scanpos = xsp;
10499 return false;
10500 }
10501
10502 final private boolean jj_3R_348() {
10503 if (jj_scan_token(OR)) return true;
10504 if (jj_3R_302()) return true;
10505 return false;
10506 }
10507
10508 final private boolean jj_3R_328() {
10509 if (jj_3R_45()) return true;
10510 if (jj_3R_235()) return true;
10511 return false;
10512 }
10513
10514 final private boolean jj_3R_327() {
10515 if (jj_3R_45()) return true;
10516 if (jj_scan_token(SEMICOLON)) return true;
10517 return false;
10518 }
10519
10520 final private boolean jj_3R_273() {
10521 Token xsp;
10522 xsp = jj_scanpos;
10523 if (jj_3R_327()) {
10524 jj_scanpos = xsp;
10525 if (jj_3R_328()) return true;
10526 }
10527 return false;
10528 }
10529
10530 final private boolean jj_3R_81() {
10531 if (jj_3R_155()) return true;
10532 Token xsp;
10533 xsp = jj_scanpos;
10534 if (jj_3_76()) jj_scanpos = xsp;
10535 return false;
10536 }
10537
10538 final private boolean jj_3_8() {
10539 if (jj_3R_42()) return true;
10540 if (jj_scan_token(SEMICOLON)) return true;
10541 return false;
10542 }
10543
10544 final private boolean jj_3R_303() {
10545 if (jj_scan_token(QUESTIONMARK)) return true;
10546 if (jj_3R_80()) return true;
10547 if (jj_scan_token(COLON)) return true;
10548 if (jj_3R_80()) return true;
10549 return false;
10550 }
10551
10552 final private boolean jj_3_9() {
10553 if (jj_3R_44()) return true;
10554 return false;
10555 }
10556
10557 final private boolean jj_3R_383() {
10558 if (jj_3R_81()) return true;
10559 Token xsp;
10560 xsp = jj_scanpos;
10561 if (jj_3R_392()) jj_scanpos = xsp;
10562 return false;
10563 }
10564
10565 final private boolean jj_3R_42() {
10566 Token xsp;
10567 xsp = jj_scanpos;
10568 if (jj_3_9()) jj_scanpos = xsp;
10569 if (jj_3R_103()) return true;
10570 return false;
10571 }
10572
10573 final private boolean jj_3R_38() {
10574 if (jj_3R_68()) return true;
10575 return false;
10576 }
10577
10578 final private boolean jj_3R_371() {
10579 if (jj_3R_383()) return true;
10580 Token xsp;
10581 xsp = jj_scanpos;
10582 if (jj_3R_384()) jj_scanpos = xsp;
10583 return false;
10584 }
10585
10586 final private boolean jj_3R_343() {
10587 if (jj_3R_78()) return true;
10588 return false;
10589 }
10590
10591 final private boolean jj_3R_330() {
10592 if (jj_3R_42()) return true;
10593 if (jj_3R_235()) return true;
10594 return false;
10595 }
10596
10597 final private boolean jj_3R_329() {
10598 if (jj_3R_42()) return true;
10599 if (jj_scan_token(SEMICOLON)) return true;
10600 return false;
10601 }
10602
10603 final private boolean jj_3R_276() {
10604 Token xsp;
10605 xsp = jj_scanpos;
10606 if (jj_3R_329()) {
10607 jj_scanpos = xsp;
10608 if (jj_3R_330()) return true;
10609 }
10610 return false;
10611 }
10612
10613 final private boolean jj_3R_347() {
10614 if (jj_3R_371()) return true;
10615 Token xsp;
10616 xsp = jj_scanpos;
10617 if (jj_3R_372()) jj_scanpos = xsp;
10618 return false;
10619 }
10620
10621 final private boolean jj_3R_272() {
10622 if (jj_3R_36()) return true;
10623 return false;
10624 }
10625
10626 final private boolean jj_3_7() {
10627 if (jj_scan_token(NAMESPACE)) return true;
10628 return false;
10629 }
10630
10631 final private boolean jj_3_6() {
10632 if (jj_3R_43()) return true;
10633 return false;
10634 }
10635
10636 final private boolean jj_3R_302() {
10637 if (jj_3R_347()) return true;
10638 Token xsp;
10639 xsp = jj_scanpos;
10640 if (jj_3R_348()) jj_scanpos = xsp;
10641 return false;
10642 }
10643
10644 final private boolean jj_3_5() {
10645 if (jj_3R_42()) return true;
10646 return false;
10647 }
10648
10649 final private boolean jj_3_4() {
10650 if (jj_3R_39()) return true;
10651 if (jj_3R_41()) return true;
10652 return false;
10653 }
10654
10655 final private boolean jj_3_3() {
10656 if (jj_3R_39()) return true;
10657 if (jj_3R_40()) return true;
10658 if (jj_scan_token(LCURLYBRACE)) return true;
10659 return false;
10660 }
10661
10662 final private boolean jj_3R_216() {
10663 if (jj_3R_278()) return true;
10664 return false;
10665 }
10666
10667 final private boolean jj_3R_342() {
10668 if (jj_3R_338()) return true;
10669 return false;
10670 }
10671
10672 final private boolean jj_3R_243() {
10673 if (jj_3R_302()) return true;
10674 Token xsp;
10675 xsp = jj_scanpos;
10676 if (jj_3R_303()) jj_scanpos = xsp;
10677 return false;
10678 }
10679
10680 final private boolean jj_3R_37() {
10681 if (jj_3R_49()) return true;
10682 return false;
10683 }
10684
10685 final private boolean jj_3_2() {
10686 Token xsp;
10687 while (true) {
10688 xsp = jj_scanpos;
10689 if (jj_3R_37()) { jj_scanpos = xsp; break; }
10690 }
10691 xsp = jj_scanpos;
10692 if (jj_3R_38()) jj_scanpos = xsp;
10693 if (jj_scan_token(OPERATOR)) return true;
10694 return false;
10695 }
10696
10697 final private boolean jj_3R_215() {
10698 if (jj_3R_277()) return true;
10699 return false;
10700 }
10701
10702 final private boolean jj_3_1() {
10703 if (jj_3R_36()) return true;
10704 return false;
10705 }
10706
10707 final private boolean jj_3R_214() {
10708 if (jj_3R_43()) return true;
10709 return false;
10710 }
10711
10712 final private boolean jj_3R_213() {
10713 if (jj_3R_276()) return true;
10714 return false;
10715 }
10716
10717 final private boolean jj_3R_241() {
10718 if (jj_3R_243()) return true;
10719 return false;
10720 }
10721
10722 final private boolean jj_3R_212() {
10723 if (jj_3R_275()) return true;
10724 return false;
10725 }
10726
10727 final private boolean jj_3R_211() {
10728 if (jj_3R_274()) return true;
10729 return false;
10730 }
10731
10732 final private boolean jj_3R_210() {
10733 if (jj_3R_273()) return true;
10734 return false;
10735 }
10736
10737 final private boolean jj_3R_154() {
10738 if (jj_3R_244()) return true;
10739 return false;
10740 }
10741
10742 final private boolean jj_3R_151() {
10743 if (jj_scan_token(COMMA)) return true;
10744 if (jj_3R_80()) return true;
10745 return false;
10746 }
10747
10748 final private boolean jj_3R_118() {
10749 Token xsp;
10750 xsp = jj_scanpos;
10751 if (jj_3R_209()) {
10752 jj_scanpos = xsp;
10753 if (jj_3R_210()) {
10754 jj_scanpos = xsp;
10755 if (jj_3R_211()) {
10756 jj_scanpos = xsp;
10757 if (jj_3R_212()) {
10758 jj_scanpos = xsp;
10759 if (jj_3R_213()) {
10760 jj_scanpos = xsp;
10761 if (jj_3R_214()) {
10762 jj_scanpos = xsp;
10763 if (jj_3R_215()) {
10764 jj_scanpos = xsp;
10765 if (jj_3R_216()) {
10766 jj_scanpos = xsp;
10767 if (jj_scan_token(18)) return true;
10768 }
10769 }
10770 }
10771 }
10772 }
10773 }
10774 }
10775 }
10776 return false;
10777 }
10778
10779 final private boolean jj_3R_209() {
10780 if (jj_3R_272()) return true;
10781 return false;
10782 }
10783
10784 final private boolean jj_3R_367() {
10785 if (jj_3R_78()) return true;
10786 return false;
10787 }
10788
10789 final private boolean jj_3R_341() {
10790 Token xsp;
10791 xsp = jj_scanpos;
10792 if (jj_3R_367()) jj_scanpos = xsp;
10793 if (jj_scan_token(SEMICOLON)) return true;
10794 return false;
10795 }
10796
10797 final private boolean jj_3_74() {
10798 if (jj_3R_80()) return true;
10799 return false;
10800 }
10801
10802 final private boolean jj_3_75() {
10803 Token xsp;
10804 xsp = jj_scanpos;
10805 if (jj_scan_token(22)) {
10806 jj_scanpos = xsp;
10807 if (jj_scan_token(23)) {
10808 jj_scanpos = xsp;
10809 if (jj_scan_token(24)) {
10810 jj_scanpos = xsp;
10811 if (jj_scan_token(25)) {
10812 jj_scanpos = xsp;
10813 if (jj_scan_token(26)) {
10814 jj_scanpos = xsp;
10815 if (jj_scan_token(27)) {
10816 jj_scanpos = xsp;
10817 if (jj_scan_token(28)) {
10818 jj_scanpos = xsp;
10819 if (jj_scan_token(29)) {
10820 jj_scanpos = xsp;
10821 if (jj_scan_token(30)) {
10822 jj_scanpos = xsp;
10823 if (jj_scan_token(31)) {
10824 jj_scanpos = xsp;
10825 if (jj_scan_token(32)) return true;
10826 }
10827 }
10828 }
10829 }
10830 }
10831 }
10832 }
10833 }
10834 }
10835 }
10836 if (jj_3R_80()) return true;
10837 return false;
10838 }
10839
10840 final private boolean jj_3R_80() {
10841 Token xsp;
10842 xsp = jj_scanpos;
10843 if (jj_3R_153()) {
10844 jj_scanpos = xsp;
10845 if (jj_3R_154()) return true;
10846 }
10847 return false;
10848 }
10849
10850 final private boolean jj_3R_153() {
10851 if (jj_3R_243()) return true;
10852 Token xsp;
10853 xsp = jj_scanpos;
10854 if (jj_3_75()) jj_scanpos = xsp;
10855 return false;
10856 }
10857
10858 final private boolean jj_3R_304() {
10859 if (jj_3R_80()) return true;
10860 return false;
10861 }
10862
10863 final private boolean jj_3R_78() {
10864 if (jj_3R_80()) return true;
10865 Token xsp;
10866 while (true) {
10867 xsp = jj_scanpos;
10868 if (jj_3R_151()) { jj_scanpos = xsp; break; }
10869 }
10870 return false;
10871 }
10872
10873 final private boolean jj_3R_244() {
10874 if (jj_scan_token(THROW)) return true;
10875 Token xsp;
10876 xsp = jj_scanpos;
10877 if (jj_3R_304()) jj_scanpos = xsp;
10878 return false;
10879 }
10880
10881 final private boolean jj_3R_368() {
10882 if (jj_3R_70()) return true;
10883 return false;
10884 }
10885
10886 final private boolean jj_3R_345() {
10887 Token xsp;
10888 xsp = jj_scanpos;
10889 if (jj_3R_368()) {
10890 jj_scanpos = xsp;
10891 if (jj_scan_token(21)) return true;
10892 }
10893 return false;
10894 }
10895
10896 final private boolean jj_3_71() {
10897 if (jj_scan_token(ELSE)) return true;
10898 return false;
10899 }
10900
10901 final private boolean jj_3R_344() {
10902 if (jj_3R_78()) return true;
10903 return false;
10904 }
10905
10906 final private boolean jj_3R_299() {
10907 if (jj_scan_token(CATCH)) return true;
10908 if (jj_scan_token(LPARENTHESIS)) return true;
10909 if (jj_3R_345()) return true;
10910 if (jj_scan_token(RPARENTHESIS)) return true;
10911 if (jj_3R_235()) return true;
10912 return false;
10913 }
10914
10915 final private boolean jj_3R_339() {
10916 if (jj_scan_token(ELSE)) return true;
10917 if (jj_3R_76()) return true;
10918 return false;
10919 }
10920
10921 final private boolean jj_3R_239() {
10922 if (jj_scan_token(TRY)) return true;
10923 if (jj_3R_235()) return true;
10924 return false;
10925 }
10926
10927 final private boolean jj_3_72() {
10928 if (jj_3R_79()) return true;
10929 return false;
10930 }
10931
10932 final private boolean jj_3R_298() {
10933 if (jj_scan_token(RETURN)) return true;
10934 Token xsp;
10935 xsp = jj_scanpos;
10936 if (jj_3R_344()) jj_scanpos = xsp;
10937 return false;
10938 }
10939
10940 final private boolean jj_3R_297() {
10941 if (jj_scan_token(BREAK)) return true;
10942 return false;
10943 }
10944
10945 final private boolean jj_3R_296() {
10946 if (jj_scan_token(CONTINUE)) return true;
10947 return false;
10948 }
10949
10950 final private boolean jj_3_73() {
10951 if (jj_3R_78()) return true;
10952 return false;
10953 }
10954
10955 final private boolean jj_3R_295() {
10956 if (jj_scan_token(GOTO)) return true;
10957 if (jj_scan_token(ID)) return true;
10958 return false;
10959 }
10960
10961 final private boolean jj_3R_238() {
10962 Token xsp;
10963 xsp = jj_scanpos;
10964 if (jj_3R_295()) {
10965 jj_scanpos = xsp;
10966 if (jj_3R_296()) {
10967 jj_scanpos = xsp;
10968 if (jj_3R_297()) {
10969 jj_scanpos = xsp;
10970 if (jj_3R_298()) return true;
10971 }
10972 }
10973 }
10974 return false;
10975 }
10976
10977 final private boolean jj_3R_340() {
10978 if (jj_3R_79()) return true;
10979 return false;
10980 }
10981
10982 final private boolean jj_3R_366() {
10983 if (jj_3R_44()) return true;
10984 if (jj_3R_71()) return true;
10985 if (jj_scan_token(ASSIGNEQUAL)) return true;
10986 if (jj_3R_80()) return true;
10987 return false;
10988 }
10989
10990 final private boolean jj_3R_365() {
10991 if (jj_3R_78()) return true;
10992 return false;
10993 }
10994
10995 final private boolean jj_3R_338() {
10996 Token xsp;
10997 xsp = jj_scanpos;
10998 if (jj_3R_365()) {
10999 jj_scanpos = xsp;
11000 if (jj_3R_366()) return true;
11001 }
11002 return false;
11003 }
11004
11005 final private boolean jj_3R_294() {
11006 if (jj_scan_token(FOR)) return true;
11007 if (jj_scan_token(LPARENTHESIS)) return true;
11008 Token xsp;
11009 xsp = jj_scanpos;
11010 if (jj_3R_340()) {
11011 jj_scanpos = xsp;
11012 if (jj_3R_341()) return true;
11013 }
11014 xsp = jj_scanpos;
11015 if (jj_3R_342()) jj_scanpos = xsp;
11016 if (jj_scan_token(SEMICOLON)) return true;
11017 xsp = jj_scanpos;
11018 if (jj_3R_343()) jj_scanpos = xsp;
11019 if (jj_scan_token(RPARENTHESIS)) return true;
11020 if (jj_3R_76()) return true;
11021 return false;
11022 }
11023
11024 final private boolean jj_3R_293() {
11025 if (jj_scan_token(DO)) return true;
11026 if (jj_3R_76()) return true;
11027 if (jj_scan_token(WHILE)) return true;
11028 if (jj_scan_token(LPARENTHESIS)) return true;
11029 if (jj_3R_338()) return true;
11030 if (jj_scan_token(RPARENTHESIS)) return true;
11031 if (jj_scan_token(SEMICOLON)) return true;
11032 return false;
11033 }
11034
11035 final private boolean jj_3R_292() {
11036 if (jj_scan_token(WHILE)) return true;
11037 if (jj_scan_token(LPARENTHESIS)) return true;
11038 if (jj_3R_338()) return true;
11039 if (jj_scan_token(RPARENTHESIS)) return true;
11040 if (jj_3R_76()) return true;
11041 return false;
11042 }
11043
11044 final private boolean jj_3R_237() {
11045 Token xsp;
11046 xsp = jj_scanpos;
11047 if (jj_3R_292()) {
11048 jj_scanpos = xsp;
11049 if (jj_3R_293()) {
11050 jj_scanpos = xsp;
11051 if (jj_3R_294()) return true;
11052 }
11053 }
11054 return false;
11055 }
11056
11057 final private boolean jj_3R_291() {
11058 if (jj_scan_token(SWITCH)) return true;
11059 if (jj_scan_token(LPARENTHESIS)) return true;
11060 if (jj_3R_338()) return true;
11061 if (jj_scan_token(RPARENTHESIS)) return true;
11062 if (jj_3R_76()) return true;
11063 return false;
11064 }
11065
11066 final private boolean jj_3R_290() {
11067 if (jj_scan_token(IF)) return true;
11068 if (jj_scan_token(LPARENTHESIS)) return true;
11069 if (jj_3R_338()) return true;
11070 if (jj_scan_token(RPARENTHESIS)) return true;
11071 if (jj_3R_76()) return true;
11072 Token xsp;
11073 xsp = jj_scanpos;
11074 if (jj_3R_339()) jj_scanpos = xsp;
11075 return false;
11076 }
11077
11078 final private boolean jj_3R_236() {
11079 Token xsp;
11080 xsp = jj_scanpos;
11081 if (jj_3R_290()) {
11082 jj_scanpos = xsp;
11083 if (jj_3R_291()) return true;
11084 }
11085 return false;
11086 }
11087
11088 final private boolean jj_3R_289() {
11089 if (jj_3R_337()) return true;
11090 return false;
11091 }
11092
11093 final private boolean jj_3R_152() {
11094 if (jj_3R_242()) return true;
11095 return false;
11096 }
11097
11098 final private boolean jj_3R_235() {
11099 if (jj_scan_token(LCURLYBRACE)) return true;
11100 Token xsp;
11101 xsp = jj_scanpos;
11102 if (jj_3R_289()) jj_scanpos = xsp;
11103 if (jj_scan_token(RCURLYBRACE)) return true;
11104 return false;
11105 }
11106
11107 final private boolean jj_3R_150() {
11108 if (jj_scan_token(_DEFAULT)) return true;
11109 if (jj_scan_token(COLON)) return true;
11110 if (jj_3R_76()) return true;
11111 return false;
11112 }
11113
11114 final private boolean jj_3R_149() {
11115 if (jj_scan_token(CASE)) return true;
11116 if (jj_3R_241()) return true;
11117 if (jj_scan_token(COLON)) return true;
11118 if (jj_3R_76()) return true;
11119 return false;
11120 }
11121
11122 final private boolean jj_3R_77() {
11123 Token xsp;
11124 xsp = jj_scanpos;
11125 if (jj_3R_148()) {
11126 jj_scanpos = xsp;
11127 if (jj_3R_149()) {
11128 jj_scanpos = xsp;
11129 if (jj_3R_150()) return true;
11130 }
11131 }
11132 return false;
11133 }
11134
11135 final private boolean jj_3R_148() {
11136 if (jj_scan_token(ID)) return true;
11137 if (jj_scan_token(COLON)) return true;
11138 if (jj_3R_76()) return true;
11139 return false;
11140 }
11141
11142 final private boolean jj_3R_192() {
11143 if (jj_scan_token(NAMESPACE)) return true;
11144 if (jj_scan_token(ID)) return true;
11145 if (jj_scan_token(ASSIGNEQUAL)) return true;
11146 if (jj_3R_127()) return true;
11147 if (jj_scan_token(SEMICOLON)) return true;
11148 return false;
11149 }
11150
11151 final private boolean jj_3_70() {
11152 if (jj_scan_token(USING)) return true;
11153 return false;
11154 }
11155
11156 final private boolean jj_3_69() {
11157 if (jj_scan_token(USING)) return true;
11158 if (jj_scan_token(NAMESPACE)) return true;
11159 return false;
11160 }
11161
11162 final private boolean jj_3R_79() {
11163 if (jj_3R_44()) return true;
11164 Token xsp;
11165 xsp = jj_scanpos;
11166 if (jj_3R_152()) jj_scanpos = xsp;
11167 if (jj_scan_token(SEMICOLON)) return true;
11168 return false;
11169 }
11170
11171 final private boolean jj_3R_107() {
11172 if (jj_3R_194()) return true;
11173 return false;
11174 }
11175
11176 final private boolean jj_3R_106() {
11177 if (jj_3R_193()) return true;
11178 return false;
11179 }
11180
11181 final private boolean jj_3R_240() {
11182 if (jj_3R_299()) return true;
11183 return false;
11184 }
11185
11186 final private boolean jj_3R_105() {
11187 if (jj_3R_192()) return true;
11188 return false;
11189 }
11190
11191 final private boolean jj_3R_43() {
11192 Token xsp;
11193 xsp = jj_scanpos;
11194 if (jj_3R_104()) {
11195 jj_scanpos = xsp;
11196 if (jj_3R_105()) {
11197 jj_scanpos = xsp;
11198 if (jj_3R_106()) {
11199 jj_scanpos = xsp;
11200 if (jj_3R_107()) return true;
11201 }
11202 }
11203 }
11204 return false;
11205 }
11206
11207 final private boolean jj_3R_104() {
11208 if (jj_3R_79()) return true;
11209 return false;
11210 }
11211
11212 final private boolean jj_3R_74() {
11213 if (jj_scan_token(ASSIGNEQUAL)) return true;
11214 if (jj_3R_70()) return true;
11215 return false;
11216 }
11217
11218 final private boolean jj_3R_147() {
11219 if (jj_3R_239()) return true;
11220 Token xsp;
11221 if (jj_3R_240()) return true;
11222 while (true) {
11223 xsp = jj_scanpos;
11224 if (jj_3R_240()) { jj_scanpos = xsp; break; }
11225 }
11226 return false;
11227 }
11228
11229 final private boolean jj_3_68() {
11230 if (jj_3R_78()) return true;
11231 if (jj_scan_token(SEMICOLON)) return true;
11232 return false;
11233 }
11234
11235 final private boolean jj_3R_146() {
11236 if (jj_3R_43()) return true;
11237 return false;
11238 }
11239
11240 final private boolean jj_3_67() {
11241 if (jj_3R_77()) return true;
11242 return false;
11243 }
11244
11245 final private boolean jj_3R_145() {
11246 if (jj_3R_238()) return true;
11247 if (jj_scan_token(SEMICOLON)) return true;
11248 return false;
11249 }
11250
11251 final private boolean jj_3R_144() {
11252 if (jj_3R_237()) return true;
11253 return false;
11254 }
11255
11256 final private boolean jj_3R_143() {
11257 if (jj_3R_236()) return true;
11258 return false;
11259 }
11260
11261 final private boolean jj_3R_220() {
11262 if (jj_scan_token(COMMA)) return true;
11263 if (jj_3R_219()) return true;
11264 return false;
11265 }
11266
11267 final private boolean jj_3_66() {
11268 if (jj_3R_76()) return true;
11269 return false;
11270 }
11271
11272 final private boolean jj_3R_142() {
11273 if (jj_3R_235()) return true;
11274 return false;
11275 }
11276
11277 final private boolean jj_3R_141() {
11278 if (jj_3R_78()) return true;
11279 if (jj_scan_token(SEMICOLON)) return true;
11280 return false;
11281 }
11282
11283 final private boolean jj_3R_76() {
11284 Token xsp;
11285 xsp = jj_scanpos;
11286 if (jj_3R_140()) {
11287 jj_scanpos = xsp;
11288 if (jj_3R_141()) {
11289 jj_scanpos = xsp;
11290 if (jj_3R_142()) {
11291 jj_scanpos = xsp;
11292 if (jj_3R_143()) {
11293 jj_scanpos = xsp;
11294 if (jj_3R_144()) {
11295 jj_scanpos = xsp;
11296 if (jj_3R_145()) {
11297 jj_scanpos = xsp;
11298 if (jj_3R_146()) {
11299 jj_scanpos = xsp;
11300 if (jj_3R_147()) {
11301 jj_scanpos = xsp;
11302 if (jj_scan_token(18)) return true;
11303 }
11304 }
11305 }
11306 }
11307 }
11308 }
11309 }
11310 }
11311 return false;
11312 }
11313
11314 final private boolean jj_3R_140() {
11315 if (jj_3R_77()) return true;
11316 return false;
11317 }
11318
11319 final private boolean jj_3_65() {
11320 if (jj_3R_75()) return true;
11321 Token xsp;
11322 xsp = jj_scanpos;
11323 if (jj_scan_token(41)) {
11324 jj_scanpos = xsp;
11325 if (jj_scan_token(19)) return true;
11326 }
11327 return false;
11328 }
11329
11330 final private boolean jj_3R_364() {
11331 if (jj_3R_76()) return true;
11332 return false;
11333 }
11334
11335 final private boolean jj_3R_232() {
11336 if (jj_3R_182()) return true;
11337 return false;
11338 }
11339
11340 final private boolean jj_3R_337() {
11341 Token xsp;
11342 if (jj_3R_364()) return true;
11343 while (true) {
11344 xsp = jj_scanpos;
11345 if (jj_3R_364()) { jj_scanpos = xsp; break; }
11346 }
11347 return false;
11348 }
11349
11350 final private boolean jj_3R_280() {
11351 if (jj_3R_83()) return true;
11352 return false;
11353 }
11354
11355 final private boolean jj_3R_257() {
11356 if (jj_scan_token(COMMA)) return true;
11357 if (jj_3R_256()) return true;
11358 return false;
11359 }
11360
11361 final private boolean jj_3R_335() {
11362 if (jj_3R_73()) return true;
11363 return false;
11364 }
11365
11366 final private boolean jj_3R_279() {
11367 if (jj_3R_75()) return true;
11368 return false;
11369 }
11370
11371 final private boolean jj_3R_219() {
11372 Token xsp;
11373 xsp = jj_scanpos;
11374 if (jj_3R_279()) {
11375 jj_scanpos = xsp;
11376 if (jj_3R_280()) return true;
11377 }
11378 return false;
11379 }
11380
11381 final private boolean jj_3R_121() {
11382 if (jj_3R_219()) return true;
11383 Token xsp;
11384 while (true) {
11385 xsp = jj_scanpos;
11386 if (jj_3R_220()) { jj_scanpos = xsp; break; }
11387 }
11388 return false;
11389 }
11390
11391 final private boolean jj_3R_53() {
11392 if (jj_scan_token(LESSTHAN)) return true;
11393 Token xsp;
11394 xsp = jj_scanpos;
11395 if (jj_3R_121()) jj_scanpos = xsp;
11396 if (jj_scan_token(GREATERTHAN)) return true;
11397 return false;
11398 }
11399
11400 final private boolean jj_3R_336() {
11401 if (jj_3R_73()) return true;
11402 return false;
11403 }
11404
11405 final private boolean jj_3R_230() {
11406 if (jj_3R_182()) return true;
11407 return false;
11408 }
11409
11410 final private boolean jj_3R_97() {
11411 if (jj_3R_179()) return true;
11412 return false;
11413 }
11414
11415 final private boolean jj_3R_319() {
11416 if (jj_3R_70()) return true;
11417 return false;
11418 }
11419
11420 final private boolean jj_3R_256() {
11421 Token xsp;
11422 xsp = jj_scanpos;
11423 if (jj_3_64()) {
11424 jj_scanpos = xsp;
11425 if (jj_3R_319()) return true;
11426 }
11427 return false;
11428 }
11429
11430 final private boolean jj_3_64() {
11431 Token xsp;
11432 xsp = jj_scanpos;
11433 if (jj_scan_token(97)) {
11434 jj_scanpos = xsp;
11435 if (jj_scan_token(104)) return true;
11436 }
11437 if (jj_scan_token(ID)) return true;
11438 xsp = jj_scanpos;
11439 if (jj_3R_74()) jj_scanpos = xsp;
11440 return false;
11441 }
11442
11443 final private boolean jj_3R_179() {
11444 if (jj_3R_256()) return true;
11445 Token xsp;
11446 while (true) {
11447 xsp = jj_scanpos;
11448 if (jj_3R_257()) { jj_scanpos = xsp; break; }
11449 }
11450 return false;
11451 }
11452
11453 final private boolean jj_3R_334() {
11454 if (jj_3R_234()) return true;
11455 return false;
11456 }
11457
11458 final private boolean jj_3R_233() {
11459 if (jj_3R_241()) return true;
11460 return false;
11461 }
11462
11463 final private boolean jj_3R_36() {
11464 if (jj_scan_token(TEMPLATE)) return true;
11465 if (jj_scan_token(LESSTHAN)) return true;
11466 Token xsp;
11467 xsp = jj_scanpos;
11468 if (jj_3R_97()) jj_scanpos = xsp;
11469 if (jj_scan_token(GREATERTHAN)) return true;
11470 return false;
11471 }
11472
11473 final private boolean jj_3_63() {
11474 if (jj_3R_73()) return true;
11475 return false;
11476 }
11477
11478 final private boolean jj_3R_138() {
11479 if (jj_scan_token(LSQUAREBRACKET)) return true;
11480 Token xsp;
11481 xsp = jj_scanpos;
11482 if (jj_3R_233()) jj_scanpos = xsp;
11483 if (jj_scan_token(RSQUAREBRACKET)) return true;
11484 return false;
11485 }
11486
11487 final private boolean jj_3R_73() {
11488 Token xsp;
11489 xsp = jj_scanpos;
11490 if (jj_3R_137()) {
11491 jj_scanpos = xsp;
11492 if (jj_3R_138()) return true;
11493 }
11494 return false;
11495 }
11496
11497 final private boolean jj_3R_137() {
11498 if (jj_3R_113()) return true;
11499 if (jj_3R_114()) return true;
11500 Token xsp;
11501 xsp = jj_scanpos;
11502 if (jj_3R_232()) jj_scanpos = xsp;
11503 return false;
11504 }
11505
11506 final private boolean jj_3R_288() {
11507 if (jj_scan_token(LPARENTHESIS)) return true;
11508 if (jj_3R_234()) return true;
11509 if (jj_scan_token(RPARENTHESIS)) return true;
11510 Token xsp;
11511 while (true) {
11512 xsp = jj_scanpos;
11513 if (jj_3R_336()) { jj_scanpos = xsp; break; }
11514 }
11515 return false;
11516 }
11517
11518 final private boolean jj_3R_287() {
11519 Token xsp;
11520 if (jj_3R_335()) return true;
11521 while (true) {
11522 xsp = jj_scanpos;
11523 if (jj_3R_335()) { jj_scanpos = xsp; break; }
11524 }
11525 return false;
11526 }
11527
11528 final private boolean jj_3R_286() {
11529 if (jj_3R_67()) return true;
11530 Token xsp;
11531 xsp = jj_scanpos;
11532 if (jj_3R_334()) jj_scanpos = xsp;
11533 return false;
11534 }
11535
11536 final private boolean jj_3R_234() {
11537 Token xsp;
11538 xsp = jj_scanpos;
11539 if (jj_3R_286()) {
11540 jj_scanpos = xsp;
11541 if (jj_3R_287()) {
11542 jj_scanpos = xsp;
11543 if (jj_3R_288()) return true;
11544 }
11545 }
11546 return false;
11547 }
11548
11549 final private boolean jj_3R_285() {
11550 if (jj_3R_241()) return true;
11551 return false;
11552 }
11553
11554 final private boolean jj_3_62() {
11555 if (jj_3R_72()) return true;
11556 return false;
11557 }
11558
11559 final private boolean jj_3R_231() {
11560 if (jj_scan_token(LSQUAREBRACKET)) return true;
11561 Token xsp;
11562 xsp = jj_scanpos;
11563 if (jj_3R_285()) jj_scanpos = xsp;
11564 if (jj_scan_token(RSQUAREBRACKET)) return true;
11565 return false;
11566 }
11567
11568 final private boolean jj_3R_136() {
11569 Token xsp;
11570 if (jj_3R_231()) return true;
11571 while (true) {
11572 xsp = jj_scanpos;
11573 if (jj_3R_231()) { jj_scanpos = xsp; break; }
11574 }
11575 return false;
11576 }
11577
11578 final private boolean jj_3R_72() {
11579 Token xsp;
11580 xsp = jj_scanpos;
11581 if (jj_3R_135()) {
11582 jj_scanpos = xsp;
11583 if (jj_3R_136()) return true;
11584 }
11585 return false;
11586 }
11587
11588 final private boolean jj_3R_135() {
11589 if (jj_3R_113()) return true;
11590 if (jj_3R_114()) return true;
11591 Token xsp;
11592 xsp = jj_scanpos;
11593 if (jj_3R_230()) jj_scanpos = xsp;
11594 return false;
11595 }
11596
11597 final private boolean jj_3R_139() {
11598 if (jj_3R_234()) return true;
11599 return false;
11600 }
11601
11602 final private boolean jj_3R_229() {
11603 if (jj_3R_72()) return true;
11604 return false;
11605 }
11606
11607 final private boolean jj_3R_228() {
11608 if (jj_scan_token(LPARENTHESIS)) return true;
11609 if (jj_3R_71()) return true;
11610 if (jj_scan_token(RPARENTHESIS)) return true;
11611 return false;
11612 }
11613
11614 final private boolean jj_3_61() {
11615 if (jj_3R_67()) return true;
11616 return false;
11617 }
11618
11619 final private boolean jj_3R_100() {
11620 if (jj_3R_182()) return true;
11621 return false;
11622 }
11623
11624 final private boolean jj_3R_227() {
11625 if (jj_3R_102()) return true;
11626 return false;
11627 }
11628
11629 final private boolean jj_3_60() {
11630 if (jj_3R_67()) return true;
11631 return false;
11632 }
11633
11634 final private boolean jj_3R_134() {
11635 Token xsp;
11636 xsp = jj_scanpos;
11637 if (jj_3R_227()) {
11638 jj_scanpos = xsp;
11639 if (jj_3R_228()) return true;
11640 }
11641 xsp = jj_scanpos;
11642 if (jj_3R_229()) jj_scanpos = xsp;
11643 return false;
11644 }
11645
11646 final private boolean jj_3R_260() {
11647 if (jj_3R_67()) return true;
11648 return false;
11649 }
11650
11651 final private boolean jj_3R_183() {
11652 Token xsp;
11653 if (jj_3R_260()) return true;
11654 while (true) {
11655 xsp = jj_scanpos;
11656 if (jj_3R_260()) { jj_scanpos = xsp; break; }
11657 }
11658 return false;
11659 }
11660
11661 final private boolean jj_3R_133() {
11662 if (jj_3R_183()) return true;
11663 return false;
11664 }
11665
11666 final private boolean jj_3R_71() {
11667 Token xsp;
11668 xsp = jj_scanpos;
11669 if (jj_3R_133()) jj_scanpos = xsp;
11670 if (jj_3R_134()) return true;
11671 return false;
11672 }
11673
11674 final private boolean jj_3_58() {
11675 if (jj_scan_token(COMMA)) return true;
11676 if (jj_3R_70()) return true;
11677 return false;
11678 }
11679
11680 final private boolean jj_3R_417() {
11681 if (jj_3R_182()) return true;
11682 return false;
11683 }
11684
11685 final private boolean jj_3_59() {
11686 if (jj_3R_71()) return true;
11687 return false;
11688 }
11689
11690 final private boolean jj_3R_75() {
11691 if (jj_3R_44()) return true;
11692 Token xsp;
11693 xsp = jj_scanpos;
11694 if (jj_3R_139()) jj_scanpos = xsp;
11695 return false;
11696 }
11697
11698 final private boolean jj_3R_388() {
11699 if (jj_3R_234()) return true;
11700 return false;
11701 }
11702
11703 final private boolean jj_3R_378() {
11704 if (jj_scan_token(ASSIGNEQUAL)) return true;
11705 if (jj_3R_80()) return true;
11706 return false;
11707 }
11708
11709 final private boolean jj_3R_377() {
11710 Token xsp;
11711 xsp = jj_scanpos;
11712 if (jj_3R_388()) jj_scanpos = xsp;
11713 return false;
11714 }
11715
11716 final private boolean jj_3R_376() {
11717 if (jj_3R_71()) return true;
11718 return false;
11719 }
11720
11721 final private boolean jj_3R_70() {
11722 if (jj_3R_44()) return true;
11723 Token xsp;
11724 xsp = jj_scanpos;
11725 if (jj_3R_376()) {
11726 jj_scanpos = xsp;
11727 if (jj_3R_377()) return true;
11728 }
11729 xsp = jj_scanpos;
11730 if (jj_3R_378()) jj_scanpos = xsp;
11731 return false;
11732 }
11733
11734 public ParserTokenManager token_source;
11735 JavaCharStream jj_input_stream;
11736 public Token token, jj_nt;
11737 private int jj_ntk;
11738 private Token jj_scanpos, jj_lastpos;
11739 private int jj_la;
11740 public boolean lookingAhead = false;
11741 private boolean jj_semLA;
11742 private int jj_gen;
11743 final private int[] jj_la1 = new int[172];
11744 static private int[] jj_la1_0;
11745 static private int[] jj_la1_1;
11746 static private int[] jj_la1_2;
11747 static private int[] jj_la1_3;
11748 static private int[] jj_la1_4;
11749 static {
11750 jj_la1_0();
11751 jj_la1_1();
11752 jj_la1_2();
11753 jj_la1_3();
11754 jj_la1_4();
11755 }
11756 private static void jj_la1_0() {
11757 jj_la1_0 = new int[] {0x54000,0x40000,0x14000,0x10000,0x0,0x0,0x400000,0x210000,0x80000,0x210000,0x10000,0x0,0x0,0x54000,0x54400,0x0,0x54000,0x0,0x10000,0x10000,0x10000,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x0,0x0,0x0,0x10000,0x0,0x0,0x80000,0x404000,0x404000,0x80000,0x14400,0x14000,0x54000,0x54000,0x0,0x0,0x0,0x0,0x0,0x0,0x54000,0x54000,0x0,0x400000,0x14000,0x40000,0x80000,0x420000,0x420000,0x0,0x0,0x400,0x80000,0x0,0x400000,0x10000,0x0,0x14000,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x20000,0x0,0x80000,0x14000,0x0,0x10000,0x0,0x0,0x0,0x0,0x15000,0x400000,0x15000,0x14000,0x0,0x14000,0x1000,0x5000,0x15000,0x5000,0x5000,0x10000,0x4000,0x0,0x14000,0x5000,0x10000,0x80000,0x0,0x400000,0x10000,0x80000,0x14000,0x14000,0x0,0x50400,0x10000,0x14000,0x0,0x54400,0x0,0x14000,0x54000,0x14000,0x14000,0x0,0x10000,0x14000,0x0,0x210000,0x80000,0xffc00000,0x14000,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14000,0x14000,0x0,0x14000,0x0,0x14000,0x0,0x5000,0x14000,0x10000,0x0,0x0,0x0,0x14000,0x4000,0x10000,0x10000,0x10000,0x11000,0x14000,0x10000,0x1000,0x80000,0x0,0xffc85000,0x10000,0x80000,};
11758 }
11759 private static void jj_la1_1() {
11760 jj_la1_1 = new int[] {0x18210020,0x0,0x18010020,0x8000000,0x8000000,0x0,0x0,0x18000000,0x0,0x18000000,0x0,0x10020,0x10020,0x18210020,0x18210020,0x0,0x18210020,0x0,0x0,0x10000000,0x0,0x18000000,0x8000000,0x8000000,0x0,0x10000000,0x0,0x100,0x0,0x0,0x100,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1079c020,0x1079c020,0x18210020,0x18210020,0x0,0x0,0x0,0x0,0x0,0x0,0x18210020,0x18210020,0x0,0x0,0x10020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1079c020,0x0,0x0,0x0,0x0,0x0,0x0,0x10020,0x0,0x10020,0x0,0x0,0x1079c020,0x0,0x0,0x10020,0x0,0x0,0x10020,0x0,0x0,0x1079c020,0x0,0x18000000,0x0,0x0,0x0,0x18000000,0x0,0x1879c020,0x1079c020,0x80000000,0x38000000,0x18000000,0x10020,0x40000000,0x7879c020,0x0,0x1079c020,0x1079c020,0x1879c020,0x1079c020,0x0,0x18000000,0x1079c020,0x20000000,0x18000000,0x0,0x1,0x1079c020,0x0,0x2,0x4,0x8,0x10,0xc0,0xc0,0xf00,0x3000,0x3000,0xc000,0x70000,0x6000000,0x6000000,0x10000000,0x79c020,0x79c020,0x180000,0x200000,0x61c020,0x1079c020,0x1800000,0x1980000,0x1079c020,0x0,0x200000,0x200000,0x200000,0x1079c020,0x0,0x200000,0x0,0x18000000,0x10020,0x1079c020,0x0,0x0,0x0,0x0,0x57fffff,0x18000000,0x0,};
11761 }
11762 private static void jj_la1_2() {
11763 jj_la1_2 = new int[] {0xb41f2f43,0x400,0xb40f2d43,0x84092402,0x84092402,0x0,0x0,0xb40f2d43,0x0,0xb40f2d43,0x0,0x0,0x0,0xb41f2f43,0xb41f2f43,0x0,0xb41f2f43,0x0,0x100,0x30060941,0x100,0xb40f2d43,0x84092402,0x84000400,0x80002,0x30060841,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70260851,0x70260851,0xb5cf2f43,0xb5cf2f43,0x0,0x0,0x1c00000,0x0,0x1c00000,0x1c00000,0xb40f2f43,0xb5cf2f43,0x1c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x200,0x10000,0x200,0x200,0x10200,0x10200,0x0,0x0,0x0,0x0,0x70260851,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70260851,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70260851,0x0,0xb40f2d43,0x0,0x0,0x0,0xb40f2d43,0x0,0xf42f2d53,0x70260851,0x0,0xbc1ffd67,0xb41f2d43,0x0,0x8,0xfc3ffd7f,0x8000,0x70260851,0x70260851,0xf42f2d53,0x70260851,0x1020,0xb40f2d43,0x70260851,0x8004004,0xb40f2d43,0x0,0x0,0x70260851,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30060841,0x40200010,0x40200010,0x0,0x40200010,0x0,0x70260851,0x0,0x0,0x70260851,0x0,0x0,0x0,0x0,0x70260851,0x0,0x0,0x0,0xb40f2d43,0x0,0x70260851,0x0,0x0,0x0,0x0,0x200010,0xb40f2d43,0x0,};
11764 }
11765 private static void jj_la1_3() {
11766 jj_la1_3 = new int[] {0x2ff4b,0x0,0x2f74b,0x25148,0x5140,0x100000,0x0,0xf74b,0x0,0xf74b,0x8,0x0,0x0,0x2ff4b,0x2ff4b,0x0,0x2ff4b,0x0,0x20b,0xa60b,0x20b,0xf74b,0x5140,0x40,0x4100,0xa400,0x8,0x0,0x8,0x8,0x0,0x8,0x0,0x8,0x20000,0x8,0x0,0x0,0x0,0x0,0xfffea498,0xfffea498,0x2ff4b,0x2ff4b,0x203,0x203,0x0,0x1000,0x1000,0x1000,0x2ff4b,0x2ff4b,0x0,0x0,0x20008,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x4000,0x20008,0x100000,0x0,0x1000,0x0,0x1000,0x1000,0x1000,0x1000,0x0,0x0,0x100000,0x0,0xfffea498,0x0,0x8,0x2000,0x100000,0x2000,0x100000,0x8,0x0,0x8,0x20008,0x100000,0xffeea498,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x100000,0xffeea498,0x0,0xf74b,0x0,0x102,0x0,0xf74b,0x0,0xffeef7db,0xffeea498,0x0,0x1ff6f,0xf74b,0x20008,0x0,0xffffffff,0x4,0xfffea498,0xfffea498,0xfffef7db,0xfffea498,0x10000,0xf74b,0xfffea498,0x0,0xf74b,0x0,0x0,0xfffea498,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa400,0xffee0098,0xffee0098,0x0,0xffee0098,0x0,0xfffea498,0x0,0x0,0xfffea498,0x8,0x0,0x0,0x20000,0xfffea498,0x10,0xffee0088,0x0,0xf74b,0x8,0xfffea498,0x0,0x0,0x0,0xffec0000,0x0,0xf74b,0x0,};
11767 }
11768 private static void jj_la1_4() {
11769 jj_la1_4 = new int[] {0x40,0x0,0x40,0x40,0x0,0x0,0x0,0x40,0x0,0x40,0x40,0x0,0x0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x0,0x0,0x77,0x77,0x40,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x40,0x40,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x77,0x40,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x40,0x40,0x0,0x77,0x0,0x0,0x40,0x0,0x0,0x40,0x0,0x0,0x77,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x77,0x77,0x0,0x40,0x40,0x40,0x40,0x77,0x0,0x77,0x77,0x77,0x77,0x0,0x40,0x77,0x0,0x40,0x0,0x0,0x77,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x77,0x77,0x0,0x77,0x0,0x77,0x0,0x0,0x77,0x40,0x0,0x0,0x40,0x77,0x20,0x57,0x0,0x40,0x40,0x77,0x0,0x0,0x0,0x17,0x0,0x40,0x0,};
11770 }
11771 final private JJCalls[] jj_2_rtns = new JJCalls[103];
11772 private boolean jj_rescan = false;
11773 private int jj_gc = 0;
11774
11775 public Parser(java.io.InputStream stream) {
11776 this(stream, null);
11777 }
11778 public Parser(java.io.InputStream stream, String encoding) {
11779 try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
11780 token_source = new ParserTokenManager(jj_input_stream);
11781 token = new Token();
11782 jj_ntk = -1;
11783 jj_gen = 0;
11784 for (int i = 0; i < 172; i++) jj_la1[i] = -1;
11785 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
11786 }
11787
11788 public void ReInit(java.io.InputStream stream) {
11789 ReInit(stream, null);
11790 }
11791 public void ReInit(java.io.InputStream stream, String encoding) {
11792 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
11793 token_source.ReInit(jj_input_stream);
11794 token = new Token();
11795 jj_ntk = -1;
11796 jjtree.reset();
11797 jj_gen = 0;
11798 for (int i = 0; i < 172; i++) jj_la1[i] = -1;
11799 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
11800 }
11801
11802 public Parser(java.io.Reader stream) {
11803 jj_input_stream = new JavaCharStream(stream, 1, 1);
11804 token_source = new ParserTokenManager(jj_input_stream);
11805 token = new Token();
11806 jj_ntk = -1;
11807 jj_gen = 0;
11808 for (int i = 0; i < 172; i++) jj_la1[i] = -1;
11809 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
11810 }
11811
11812 public void ReInit(java.io.Reader stream) {
11813 jj_input_stream.ReInit(stream, 1, 1);
11814 token_source.ReInit(jj_input_stream);
11815 token = new Token();
11816 jj_ntk = -1;
11817 jjtree.reset();
11818 jj_gen = 0;
11819 for (int i = 0; i < 172; i++) jj_la1[i] = -1;
11820 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
11821 }
11822
11823 public Parser(ParserTokenManager tm) {
11824 token_source = tm;
11825 token = new Token();
11826 jj_ntk = -1;
11827 jj_gen = 0;
11828 for (int i = 0; i < 172; i++) jj_la1[i] = -1;
11829 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
11830 }
11831
11832 public void ReInit(ParserTokenManager tm) {
11833 token_source = tm;
11834 token = new Token();
11835 jj_ntk = -1;
11836 jjtree.reset();
11837 jj_gen = 0;
11838 for (int i = 0; i < 172; i++) jj_la1[i] = -1;
11839 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
11840 }
11841
11842 final private Token jj_consume_token(int kind) throws ParseException {
11843 Token oldToken;
11844 if ((oldToken = token).next != null) token = token.next;
11845 else token = token.next = token_source.getNextToken();
11846 jj_ntk = -1;
11847 if (token.kind == kind) {
11848 jj_gen++;
11849 if (++jj_gc > 100) {
11850 jj_gc = 0;
11851 for (int i = 0; i < jj_2_rtns.length; i++) {
11852 JJCalls c = jj_2_rtns[i];
11853 while (c != null) {
11854 if (c.gen < jj_gen) c.first = null;
11855 c = c.next;
11856 }
11857 }
11858 }
11859 return token;
11860 }
11861 token = oldToken;
11862 jj_kind = kind;
11863 throw generateParseException();
11864 }
11865
11866 static private final class LookaheadSuccess extends java.lang.Error { }
11867 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
11868 final private boolean jj_scan_token(int kind) {
11869 if (jj_scanpos == jj_lastpos) {
11870 jj_la--;
11871 if (jj_scanpos.next == null) {
11872 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
11873 } else {
11874 jj_lastpos = jj_scanpos = jj_scanpos.next;
11875 }
11876 } else {
11877 jj_scanpos = jj_scanpos.next;
11878 }
11879 if (jj_rescan) {
11880 int i = 0; Token tok = token;
11881 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
11882 if (tok != null) jj_add_error_token(kind, i);
11883 }
11884 if (jj_scanpos.kind != kind) return true;
11885 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
11886 return false;
11887 }
11888
11889 final public Token getNextToken() {
11890 if (token.next != null) token = token.next;
11891 else token = token.next = token_source.getNextToken();
11892 jj_ntk = -1;
11893 jj_gen++;
11894 return token;
11895 }
11896
11897 final public Token getToken(int index) {
11898 Token t = lookingAhead ? jj_scanpos : token;
11899 for (int i = 0; i < index; i++) {
11900 if (t.next != null) t = t.next;
11901 else t = t.next = token_source.getNextToken();
11902 }
11903 return t;
11904 }
11905
11906 final private int jj_ntk() {
11907 if ((jj_nt=token.next) == null)
11908 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
11909 else
11910 return (jj_ntk = jj_nt.kind);
11911 }
11912
11913 private java.util.Vector jj_expentries = new java.util.Vector();
11914 private int[] jj_expentry;
11915 private int jj_kind = -1;
11916 private int[] jj_lasttokens = new int[100];
11917 private int jj_endpos;
11918
11919 private void jj_add_error_token(int kind, int pos) {
11920 if (pos >= 100) return;
11921 if (pos == jj_endpos + 1) {
11922 jj_lasttokens[jj_endpos++] = kind;
11923 } else if (jj_endpos != 0) {
11924 jj_expentry = new int[jj_endpos];
11925 for (int i = 0; i < jj_endpos; i++) {
11926 jj_expentry[i] = jj_lasttokens[i];
11927 }
11928 boolean exists = false;
11929 for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
11930 int[] oldentry = (int[])(e.nextElement());
11931 if (oldentry.length == jj_expentry.length) {
11932 exists = true;
11933 for (int i = 0; i < jj_expentry.length; i++) {
11934 if (oldentry[i] != jj_expentry[i]) {
11935 exists = false;
11936 break;
11937 }
11938 }
11939 if (exists) break;
11940 }
11941 }
11942 if (!exists) jj_expentries.addElement(jj_expentry);
11943 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
11944 }
11945 }
11946
11947 public ParseException generateParseException() {
11948 jj_expentries.removeAllElements();
11949 boolean[] la1tokens = new boolean[135];
11950 for (int i = 0; i < 135; i++) {
11951 la1tokens[i] = false;
11952 }
11953 if (jj_kind >= 0) {
11954 la1tokens[jj_kind] = true;
11955 jj_kind = -1;
11956 }
11957 for (int i = 0; i < 172; i++) {
11958 if (jj_la1[i] == jj_gen) {
11959 for (int j = 0; j < 32; j++) {
11960 if ((jj_la1_0[i] & (1<<j)) != 0) {
11961 la1tokens[j] = true;
11962 }
11963 if ((jj_la1_1[i] & (1<<j)) != 0) {
11964 la1tokens[32+j] = true;
11965 }
11966 if ((jj_la1_2[i] & (1<<j)) != 0) {
11967 la1tokens[64+j] = true;
11968 }
11969 if ((jj_la1_3[i] & (1<<j)) != 0) {
11970 la1tokens[96+j] = true;
11971 }
11972 if ((jj_la1_4[i] & (1<<j)) != 0) {
11973 la1tokens[128+j] = true;
11974 }
11975 }
11976 }
11977 }
11978 for (int i = 0; i < 135; i++) {
11979 if (la1tokens[i]) {
11980 jj_expentry = new int[1];
11981 jj_expentry[0] = i;
11982 jj_expentries.addElement(jj_expentry);
11983 }
11984 }
11985 jj_endpos = 0;
11986 jj_rescan_token();
11987 jj_add_error_token(0, 0);
11988 int[][] exptokseq = new int[jj_expentries.size()][];
11989 for (int i = 0; i < jj_expentries.size(); i++) {
11990 exptokseq[i] = (int[])jj_expentries.elementAt(i);
11991 }
11992 return new ParseException(token, exptokseq, tokenImage);
11993 }
11994
11995 final public void enable_tracing() {
11996 }
11997
11998 final public void disable_tracing() {
11999 }
12000
12001 final private void jj_rescan_token() {
12002 jj_rescan = true;
12003 for (int i = 0; i < 103; i++) {
12004 try {
12005 JJCalls p = jj_2_rtns[i];
12006 do {
12007 if (p.gen > jj_gen) {
12008 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
12009 switch (i) {
12010 case 0: jj_3_1(); break;
12011 case 1: jj_3_2(); break;
12012 case 2: jj_3_3(); break;
12013 case 3: jj_3_4(); break;
12014 case 4: jj_3_5(); break;
12015 case 5: jj_3_6(); break;
12016 case 6: jj_3_7(); break;
12017 case 7: jj_3_8(); break;
12018 case 8: jj_3_9(); break;
12019 case 9: jj_3_10(); break;
12020 case 10: jj_3_11(); break;
12021 case 11: jj_3_12(); break;
12022 case 12: jj_3_13(); break;
12023 case 13: jj_3_14(); break;
12024 case 14: jj_3_15(); break;
12025 case 15: jj_3_16(); break;
12026 case 16: jj_3_17(); break;
12027 case 17: jj_3_18(); break;
12028 case 18: jj_3_19(); break;
12029 case 19: jj_3_20(); break;
12030 case 20: jj_3_21(); break;
12031 case 21: jj_3_22(); break;
12032 case 22: jj_3_23(); break;
12033 case 23: jj_3_24(); break;
12034 case 24: jj_3_25(); break;
12035 case 25: jj_3_26(); break;
12036 case 26: jj_3_27(); break;
12037 case 27: jj_3_28(); break;
12038 case 28: jj_3_29(); break;
12039 case 29: jj_3_30(); break;
12040 case 30: jj_3_31(); break;
12041 case 31: jj_3_32(); break;
12042 case 32: jj_3_33(); break;
12043 case 33: jj_3_34(); break;
12044 case 34: jj_3_35(); break;
12045 case 35: jj_3_36(); break;
12046 case 36: jj_3_37(); break;
12047 case 37: jj_3_38(); break;
12048 case 38: jj_3_39(); break;
12049 case 39: jj_3_40(); break;
12050 case 40: jj_3_41(); break;
12051 case 41: jj_3_42(); break;
12052 case 42: jj_3_43(); break;
12053 case 43: jj_3_44(); break;
12054 case 44: jj_3_45(); break;
12055 case 45: jj_3_46(); break;
12056 case 46: jj_3_47(); break;
12057 case 47: jj_3_48(); break;
12058 case 48: jj_3_49(); break;
12059 case 49: jj_3_50(); break;
12060 case 50: jj_3_51(); break;
12061 case 51: jj_3_52(); break;
12062 case 52: jj_3_53(); break;
12063 case 53: jj_3_54(); break;
12064 case 54: jj_3_55(); break;
12065 case 55: jj_3_56(); break;
12066 case 56: jj_3_57(); break;
12067 case 57: jj_3_58(); break;
12068 case 58: jj_3_59(); break;
12069 case 59: jj_3_60(); break;
12070 case 60: jj_3_61(); break;
12071 case 61: jj_3_62(); break;
12072 case 62: jj_3_63(); break;
12073 case 63: jj_3_64(); break;
12074 case 64: jj_3_65(); break;
12075 case 65: jj_3_66(); break;
12076 case 66: jj_3_67(); break;
12077 case 67: jj_3_68(); break;
12078 case 68: jj_3_69(); break;
12079 case 69: jj_3_70(); break;
12080 case 70: jj_3_71(); break;
12081 case 71: jj_3_72(); break;
12082 case 72: jj_3_73(); break;
12083 case 73: jj_3_74(); break;
12084 case 74: jj_3_75(); break;
12085 case 75: jj_3_76(); break;
12086 case 76: jj_3_77(); break;
12087 case 77: jj_3_78(); break;
12088 case 78: jj_3_79(); break;
12089 case 79: jj_3_80(); break;
12090 case 80: jj_3_81(); break;
12091 case 81: jj_3_82(); break;
12092 case 82: jj_3_83(); break;
12093 case 83: jj_3_84(); break;
12094 case 84: jj_3_85(); break;
12095 case 85: jj_3_86(); break;
12096 case 86: jj_3_87(); break;
12097 case 87: jj_3_88(); break;
12098 case 88: jj_3_89(); break;
12099 case 89: jj_3_90(); break;
12100 case 90: jj_3_91(); break;
12101 case 91: jj_3_92(); break;
12102 case 92: jj_3_93(); break;
12103 case 93: jj_3_94(); break;
12104 case 94: jj_3_95(); break;
12105 case 95: jj_3_96(); break;
12106 case 96: jj_3_97(); break;
12107 case 97: jj_3_98(); break;
12108 case 98: jj_3_99(); break;
12109 case 99: jj_3_100(); break;
12110 case 100: jj_3_101(); break;
12111 case 101: jj_3_102(); break;
12112 case 102: jj_3_103(); break;
12113 }
12114 }
12115 p = p.next;
12116 } while (p != null);
12117 } catch(LookaheadSuccess ls) { }
12118 }
12119 jj_rescan = false;
12120 }
12121
12122 final private void jj_save(int index, int xla) {
12123 JJCalls p = jj_2_rtns[index];
12124 while (p.gen > jj_gen) {
12125 if (p.next == null) { p = p.next = new JJCalls(); break; }
12126 p = p.next;
12127 }
12128 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
12129 }
12130
12131 static final class JJCalls {
12132 int gen;
12133 Token first;
12134 int arg;
12135 JJCalls next;
12136 }
12137
12138 }