GlueGen v2.6.0-rc-20250712
GlueGen, Native Binding Generator for Java™ (public API).
GnuCTreeParser.java
Go to the documentation of this file.
1// $ANTLR 2.7.7 (2006-11-01): "GnuCTreeParser.g" -> "GnuCTreeParser.java"$
2
3 package com.jogamp.gluegen.cgram;
4
5 import java.io.*;
6
7 import antlr.CommonAST;
8 import antlr.DumpASTVisitor;
9
10import antlr.TreeParser;
11import antlr.Token;
12import antlr.collections.AST;
13import antlr.RecognitionException;
14import antlr.ANTLRException;
15import antlr.NoViableAltException;
16import antlr.MismatchedTokenException;
17import antlr.SemanticException;
18import antlr.collections.impl.BitSet;
19import antlr.ASTPair;
20import antlr.collections.impl.ASTArray;
21
22
23public class GnuCTreeParser extends antlr.TreeParser implements GnuCTreeParserTokenTypes
24 {
25
26 int traceDepth = 0;
27 public void reportError(RecognitionException ex) {
28 if ( ex != null) {
29 System.err.println("ANTLR Tree Parsing RecognitionException Error: " + ex.getClass().getName() + " " + ex );
30 ex.printStackTrace(System.err);
31 }
32 }
33 public void reportError(NoViableAltException ex) {
34 System.err.println("ANTLR Tree Parsing NoViableAltException Error: " + ex.toString());
35 TNode.printTree( ex.node );
36 ex.printStackTrace(System.err);
37 }
38 public void reportError(MismatchedTokenException ex) {
39 if ( ex != null) {
40 TNode.printTree( ex.node );
41 System.err.println("ANTLR Tree Parsing MismatchedTokenException Error: " + ex );
42 ex.printStackTrace(System.err);
43 }
44 }
45 public void reportError(String s) {
46 System.err.println("ANTLR Error from String: " + s);
47 }
48 public void reportWarning(String s) {
49 System.err.println("ANTLR Warning from String: " + s);
50 }
51 protected void match(AST t, int ttype) throws MismatchedTokenException {
52 //System.out.println("match("+ttype+"); cursor is "+t);
53 super.match(t, ttype);
54 }
55 public void match(AST t, BitSet b) throws MismatchedTokenException {
56 //System.out.println("match("+b+"); cursor is "+t);
57 super.match(t, b);
58 }
59 protected void matchNot(AST t, int ttype) throws MismatchedTokenException {
60 //System.out.println("matchNot("+ttype+"); cursor is "+t);
61 super.matchNot(t, ttype);
62 }
63 public void traceIn(String rname, AST t) {
64 traceDepth += 1;
65 for (int x=0; x<traceDepth; x++) System.out.print(" ");
66 super.traceIn(rname, t);
67 }
68 public void traceOut(String rname, AST t) {
69 for (int x=0; x<traceDepth; x++) System.out.print(" ");
70 super.traceOut(rname, t);
71 traceDepth -= 1;
72 }
73
74
76 tokenNames = _tokenNames;
77}
78
79 public final void translationUnit(AST _t) throws RecognitionException {
80
81 TNode translationUnit_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
82
83 {
84 if (_t==null) _t=ASTNULL;
85 switch ( _t.getType()) {
86 case LITERAL_asm:
87 case SEMI:
88 case NDeclaration:
89 case NFunctionDef:
90 case NTypeMissing:
91 {
92 externalList(_t);
93 _t = _retTree;
94 break;
95 }
96 case 3:
97 {
98 break;
99 }
100 default:
101 {
102 throw new NoViableAltException(_t);
103 }
104 }
105 }
106 _retTree = _t;
107 }
108
109 public final void externalList(AST _t) throws RecognitionException {
110
111 TNode externalList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
112
113 try { // for error handling
114 {
115 int _cnt5=0;
116 _loop5:
117 do {
118 if (_t==null) _t=ASTNULL;
119 if ((_tokenSet_0.member(_t.getType()))) {
120 externalDef(_t);
121 _t = _retTree;
122 }
123 else {
124 if ( _cnt5>=1 ) { break _loop5; } else {throw new NoViableAltException(_t);}
125 }
126
127 _cnt5++;
128 } while (true);
129 }
130 }
131 catch (RecognitionException ex) {
132 if (inputState.guessing==0) {
133 reportError(ex);
134 if (_t!=null) {_t = _t.getNextSibling();}
135 } else {
136 throw ex;
137 }
138 }
139 _retTree = _t;
140 }
141
142 public final void externalDef(AST _t) throws RecognitionException {
143
144 TNode externalDef_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
145
146 try { // for error handling
147 if (_t==null) _t=ASTNULL;
148 switch ( _t.getType()) {
149 case NDeclaration:
150 {
151 declaration(_t);
152 _t = _retTree;
153 break;
154 }
155 case NFunctionDef:
156 {
157 functionDef(_t);
158 _t = _retTree;
159 break;
160 }
161 case LITERAL_asm:
162 {
163 asm_expr(_t);
164 _t = _retTree;
165 break;
166 }
167 case SEMI:
168 {
169 TNode tmp1_AST_in = (TNode)_t;
170 match(_t,SEMI);
171 _t = _t.getNextSibling();
172 break;
173 }
174 case NTypeMissing:
175 {
177 _t = _retTree;
178 break;
179 }
180 default:
181 {
182 throw new NoViableAltException(_t);
183 }
184 }
185 }
186 catch (RecognitionException ex) {
187 if (inputState.guessing==0) {
188 reportError(ex);
189 if (_t!=null) {_t = _t.getNextSibling();}
190 } else {
191 throw ex;
192 }
193 }
194 _retTree = _t;
195 }
196
197 public final void declaration(AST _t) throws RecognitionException {
198
199 TNode declaration_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
200
201 try { // for error handling
202 AST __t15 = _t;
203 TNode tmp2_AST_in = (TNode)_t;
205 _t = _t.getFirstChild();
206 declSpecifiers(_t);
207 _t = _retTree;
208 {
209 if (_t==null) _t=ASTNULL;
210 switch ( _t.getType()) {
211 case NInitDecl:
212 {
213 initDeclList(_t);
214 _t = _retTree;
215 break;
216 }
217 case SEMI:
218 {
219 break;
220 }
221 default:
222 {
223 throw new NoViableAltException(_t);
224 }
225 }
226 }
227 {
228 int _cnt18=0;
229 _loop18:
230 do {
231 if (_t==null) _t=ASTNULL;
232 if ((_t.getType()==SEMI)) {
233 TNode tmp3_AST_in = (TNode)_t;
234 match(_t,SEMI);
235 _t = _t.getNextSibling();
236 }
237 else {
238 if ( _cnt18>=1 ) { break _loop18; } else {throw new NoViableAltException(_t);}
239 }
240
241 _cnt18++;
242 } while (true);
243 }
244 _t = __t15;
245 _t = _t.getNextSibling();
246 }
247 catch (RecognitionException ex) {
248 if (inputState.guessing==0) {
249 reportError(ex);
250 if (_t!=null) {_t = _t.getNextSibling();}
251 } else {
252 throw ex;
253 }
254 }
255 _retTree = _t;
256 }
257
258 public final void functionDef(AST _t) throws RecognitionException {
259
260 TNode functionDef_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
261
262 try { // for error handling
263 AST __t125 = _t;
264 TNode tmp4_AST_in = (TNode)_t;
266 _t = _t.getFirstChild();
267 {
268 if (_t==null) _t=ASTNULL;
269 switch ( _t.getType()) {
270 case LITERAL_volatile:
271 case LITERAL_struct:
272 case LITERAL_union:
273 case LITERAL_enum:
274 case LITERAL_extern:
275 case LITERAL_static:
276 case LITERAL_const:
277 case LITERAL_void:
278 case LITERAL_char:
279 case LITERAL_short:
280 case LITERAL_int:
281 case LITERAL_long:
282 case LITERAL_float:
283 case LITERAL_double:
284 case LITERAL_signed:
285 case LITERAL_unsigned:
286 case 27:
287 case 28:
288 case 29:
289 case 30:
290 case 31:
291 case 32:
292 case LITERAL_wchar_t:
293 case 34:
294 case 35:
295 case 36:
296 case 37:
298 case LITERAL_intptr_t:
299 case LITERAL_size_t:
301 case NTypedefName:
302 case LITERAL_inline:
303 case LITERAL_typeof:
305 {
307 _t = _retTree;
308 break;
309 }
310 case NDeclarator:
311 {
312 break;
313 }
314 default:
315 {
316 throw new NoViableAltException(_t);
317 }
318 }
319 }
320 declarator(_t);
321 _t = _retTree;
322 {
323 _loop128:
324 do {
325 if (_t==null) _t=ASTNULL;
326 switch ( _t.getType()) {
327 case NDeclaration:
328 {
329 declaration(_t);
330 _t = _retTree;
331 break;
332 }
333 case VARARGS:
334 {
335 TNode tmp5_AST_in = (TNode)_t;
336 match(_t,VARARGS);
337 _t = _t.getNextSibling();
338 break;
339 }
340 default:
341 {
342 break _loop128;
343 }
344 }
345 } while (true);
346 }
348 _t = _retTree;
349 _t = __t125;
350 _t = _t.getNextSibling();
351 }
352 catch (RecognitionException ex) {
353 if (inputState.guessing==0) {
354 reportError(ex);
355 if (_t!=null) {_t = _t.getNextSibling();}
356 } else {
357 throw ex;
358 }
359 }
360 _retTree = _t;
361 }
362
363 public final void asm_expr(AST _t) throws RecognitionException {
364
365 TNode asm_expr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
366
367 try { // for error handling
368 AST __t10 = _t;
369 TNode tmp6_AST_in = (TNode)_t;
370 match(_t,LITERAL_asm);
371 _t = _t.getFirstChild();
372 {
373 if (_t==null) _t=ASTNULL;
374 switch ( _t.getType()) {
375 case LITERAL_volatile:
376 {
377 TNode tmp7_AST_in = (TNode)_t;
379 _t = _t.getNextSibling();
380 break;
381 }
382 case LCURLY:
383 {
384 break;
385 }
386 default:
387 {
388 throw new NoViableAltException(_t);
389 }
390 }
391 }
392 TNode tmp8_AST_in = (TNode)_t;
393 match(_t,LCURLY);
394 _t = _t.getNextSibling();
395 expr(_t);
396 _t = _retTree;
397 TNode tmp9_AST_in = (TNode)_t;
398 match(_t,RCURLY);
399 _t = _t.getNextSibling();
400 {
401 int _cnt13=0;
402 _loop13:
403 do {
404 if (_t==null) _t=ASTNULL;
405 if ((_t.getType()==SEMI)) {
406 TNode tmp10_AST_in = (TNode)_t;
407 match(_t,SEMI);
408 _t = _t.getNextSibling();
409 }
410 else {
411 if ( _cnt13>=1 ) { break _loop13; } else {throw new NoViableAltException(_t);}
412 }
413
414 _cnt13++;
415 } while (true);
416 }
417 _t = __t10;
418 _t = _t.getNextSibling();
419 }
420 catch (RecognitionException ex) {
421 if (inputState.guessing==0) {
422 reportError(ex);
423 if (_t!=null) {_t = _t.getNextSibling();}
424 } else {
425 throw ex;
426 }
427 }
428 _retTree = _t;
429 }
430
431 public final void typelessDeclaration(AST _t) throws RecognitionException {
432
433 TNode typelessDeclaration_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
434
435 try { // for error handling
436 AST __t8 = _t;
437 TNode tmp11_AST_in = (TNode)_t;
439 _t = _t.getFirstChild();
440 initDeclList(_t);
441 _t = _retTree;
442 TNode tmp12_AST_in = (TNode)_t;
443 match(_t,SEMI);
444 _t = _t.getNextSibling();
445 _t = __t8;
446 _t = _t.getNextSibling();
447 }
448 catch (RecognitionException ex) {
449 if (inputState.guessing==0) {
450 reportError(ex);
451 if (_t!=null) {_t = _t.getNextSibling();}
452 } else {
453 throw ex;
454 }
455 }
456 _retTree = _t;
457 }
458
459 public final void initDeclList(AST _t) throws RecognitionException {
460
461 TNode initDeclList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
462
463 try { // for error handling
464 {
465 int _cnt78=0;
466 _loop78:
467 do {
468 if (_t==null) _t=ASTNULL;
469 if ((_t.getType()==NInitDecl)) {
470 initDecl(_t);
471 _t = _retTree;
472 }
473 else {
474 if ( _cnt78>=1 ) { break _loop78; } else {throw new NoViableAltException(_t);}
475 }
476
477 _cnt78++;
478 } while (true);
479 }
480 }
481 catch (RecognitionException ex) {
482 if (inputState.guessing==0) {
483 reportError(ex);
484 if (_t!=null) {_t = _t.getNextSibling();}
485 } else {
486 throw ex;
487 }
488 }
489 _retTree = _t;
490 }
491
492 public final void expr(AST _t) throws RecognitionException {
493
494 TNode expr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
495
496 try { // for error handling
497 if (_t==null) _t=ASTNULL;
498 switch ( _t.getType()) {
499 case ASSIGN:
500 case DIV_ASSIGN:
501 case PLUS_ASSIGN:
502 case MINUS_ASSIGN:
503 case STAR_ASSIGN:
504 case MOD_ASSIGN:
505 case RSHIFT_ASSIGN:
506 case LSHIFT_ASSIGN:
507 case BAND_ASSIGN:
508 case BOR_ASSIGN:
509 case BXOR_ASSIGN:
510 {
511 assignExpr(_t);
512 _t = _retTree;
513 break;
514 }
515 case QUESTION:
516 {
517 conditionalExpr(_t);
518 _t = _retTree;
519 break;
520 }
521 case LOR:
522 {
523 logicalOrExpr(_t);
524 _t = _retTree;
525 break;
526 }
527 case LAND:
528 {
529 logicalAndExpr(_t);
530 _t = _retTree;
531 break;
532 }
533 case BOR:
534 {
535 inclusiveOrExpr(_t);
536 _t = _retTree;
537 break;
538 }
539 case BXOR:
540 {
541 exclusiveOrExpr(_t);
542 _t = _retTree;
543 break;
544 }
545 case BAND:
546 {
547 bitAndExpr(_t);
548 _t = _retTree;
549 break;
550 }
551 case EQUAL:
552 case NOT_EQUAL:
553 {
554 equalityExpr(_t);
555 _t = _retTree;
556 break;
557 }
558 case LT:
559 case LTE:
560 case GT:
561 case GTE:
562 {
563 relationalExpr(_t);
564 _t = _retTree;
565 break;
566 }
567 case LSHIFT:
568 case RSHIFT:
569 {
570 shiftExpr(_t);
571 _t = _retTree;
572 break;
573 }
574 case PLUS:
575 case MINUS:
576 {
577 additiveExpr(_t);
578 _t = _retTree;
579 break;
580 }
581 case STAR:
582 case DIV:
583 case MOD:
584 {
585 multExpr(_t);
586 _t = _retTree;
587 break;
588 }
589 case NCast:
590 {
591 castExpr(_t);
592 _t = _retTree;
593 break;
594 }
595 case INC:
596 case DEC:
597 case LITERAL_sizeof:
598 case NUnaryExpr:
600 {
601 unaryExpr(_t);
602 _t = _retTree;
603 break;
604 }
605 case NPostfixExpr:
606 {
607 postfixExpr(_t);
608 _t = _retTree;
609 break;
610 }
611 case ID:
612 case CharLiteral:
613 case NExpressionGroup:
614 case NStringSeq:
615 case Number:
616 {
617 primaryExpr(_t);
618 _t = _retTree;
619 break;
620 }
621 case NCommaExpr:
622 {
623 commaExpr(_t);
624 _t = _retTree;
625 break;
626 }
627 case NEmptyExpression:
628 {
629 emptyExpr(_t);
630 _t = _retTree;
631 break;
632 }
633 case LPAREN:
634 {
636 _t = _retTree;
637 break;
638 }
639 case NInitializer:
641 {
642 initializer(_t);
643 _t = _retTree;
644 break;
645 }
646 case NRangeExpr:
647 {
648 rangeExpr(_t);
649 _t = _retTree;
650 break;
651 }
652 case NGnuAsmExpr:
653 {
654 gnuAsmExpr(_t);
655 _t = _retTree;
656 break;
657 }
658 default:
659 {
660 throw new NoViableAltException(_t);
661 }
662 }
663 }
664 catch (RecognitionException ex) {
665 if (inputState.guessing==0) {
666 reportError(ex);
667 if (_t!=null) {_t = _t.getNextSibling();}
668 } else {
669 throw ex;
670 }
671 }
672 _retTree = _t;
673 }
674
675 public final void declSpecifiers(AST _t) throws RecognitionException {
676
677 TNode declSpecifiers_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
678
679 try { // for error handling
680 {
681 int _cnt21=0;
682 _loop21:
683 do {
684 if (_t==null) _t=ASTNULL;
685 switch ( _t.getType()) {
686 case LITERAL_typedef:
687 case LITERAL_auto:
688 case LITERAL_register:
689 case LITERAL_extern:
690 case LITERAL_static:
691 case LITERAL_inline:
692 {
694 _t = _retTree;
695 break;
696 }
697 case LITERAL_volatile:
698 case LITERAL_const:
699 {
700 typeQualifier(_t);
701 _t = _retTree;
702 break;
703 }
704 case LITERAL_struct:
705 case LITERAL_union:
706 case LITERAL_enum:
707 case LITERAL_void:
708 case LITERAL_char:
709 case LITERAL_short:
710 case LITERAL_int:
711 case LITERAL_long:
712 case LITERAL_float:
713 case LITERAL_double:
714 case LITERAL_signed:
715 case LITERAL_unsigned:
716 case 27:
717 case 28:
718 case 29:
719 case 30:
720 case 31:
721 case 32:
722 case LITERAL_wchar_t:
723 case 34:
724 case 35:
725 case 36:
726 case 37:
728 case LITERAL_intptr_t:
729 case LITERAL_size_t:
731 case NTypedefName:
732 case LITERAL_typeof:
734 {
735 typeSpecifier(_t);
736 _t = _retTree;
737 break;
738 }
739 default:
740 {
741 if ( _cnt21>=1 ) { break _loop21; } else {throw new NoViableAltException(_t);}
742 }
743 }
744 _cnt21++;
745 } while (true);
746 }
747 }
748 catch (RecognitionException ex) {
749 if (inputState.guessing==0) {
750 reportError(ex);
751 if (_t!=null) {_t = _t.getNextSibling();}
752 } else {
753 throw ex;
754 }
755 }
756 _retTree = _t;
757 }
758
759 public final void storageClassSpecifier(AST _t) throws RecognitionException {
760
761 TNode storageClassSpecifier_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
762
763 try { // for error handling
764 if (_t==null) _t=ASTNULL;
765 switch ( _t.getType()) {
766 case LITERAL_auto:
767 {
768 TNode tmp13_AST_in = (TNode)_t;
770 _t = _t.getNextSibling();
771 break;
772 }
773 case LITERAL_register:
774 {
775 TNode tmp14_AST_in = (TNode)_t;
777 _t = _t.getNextSibling();
778 break;
779 }
780 case LITERAL_typedef:
781 {
782 TNode tmp15_AST_in = (TNode)_t;
784 _t = _t.getNextSibling();
785 break;
786 }
787 case LITERAL_extern:
788 case LITERAL_static:
789 case LITERAL_inline:
790 {
792 _t = _retTree;
793 break;
794 }
795 default:
796 {
797 throw new NoViableAltException(_t);
798 }
799 }
800 }
801 catch (RecognitionException ex) {
802 if (inputState.guessing==0) {
803 reportError(ex);
804 if (_t!=null) {_t = _t.getNextSibling();}
805 } else {
806 throw ex;
807 }
808 }
809 _retTree = _t;
810 }
811
812 public final void typeQualifier(AST _t) throws RecognitionException {
813
814 TNode typeQualifier_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
815
816 try { // for error handling
817 if (_t==null) _t=ASTNULL;
818 switch ( _t.getType()) {
819 case LITERAL_const:
820 {
821 TNode tmp16_AST_in = (TNode)_t;
823 _t = _t.getNextSibling();
824 break;
825 }
826 case LITERAL_volatile:
827 {
828 TNode tmp17_AST_in = (TNode)_t;
830 _t = _t.getNextSibling();
831 break;
832 }
833 default:
834 {
835 throw new NoViableAltException(_t);
836 }
837 }
838 }
839 catch (RecognitionException ex) {
840 if (inputState.guessing==0) {
841 reportError(ex);
842 if (_t!=null) {_t = _t.getNextSibling();}
843 } else {
844 throw ex;
845 }
846 }
847 _retTree = _t;
848 }
849
850 public final void typeSpecifier(AST _t) throws RecognitionException {
851
852 TNode typeSpecifier_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
853
854 try { // for error handling
855 if (_t==null) _t=ASTNULL;
856 switch ( _t.getType()) {
857 case LITERAL_void:
858 {
859 TNode tmp18_AST_in = (TNode)_t;
861 _t = _t.getNextSibling();
862 break;
863 }
864 case LITERAL_char:
865 {
866 TNode tmp19_AST_in = (TNode)_t;
868 _t = _t.getNextSibling();
869 break;
870 }
871 case LITERAL_short:
872 {
873 TNode tmp20_AST_in = (TNode)_t;
875 _t = _t.getNextSibling();
876 break;
877 }
878 case LITERAL_int:
879 {
880 TNode tmp21_AST_in = (TNode)_t;
881 match(_t,LITERAL_int);
882 _t = _t.getNextSibling();
883 break;
884 }
885 case LITERAL_long:
886 {
887 TNode tmp22_AST_in = (TNode)_t;
889 _t = _t.getNextSibling();
890 break;
891 }
892 case LITERAL_float:
893 {
894 TNode tmp23_AST_in = (TNode)_t;
896 _t = _t.getNextSibling();
897 break;
898 }
899 case LITERAL_double:
900 {
901 TNode tmp24_AST_in = (TNode)_t;
903 _t = _t.getNextSibling();
904 break;
905 }
906 case LITERAL_signed:
907 {
908 TNode tmp25_AST_in = (TNode)_t;
910 _t = _t.getNextSibling();
911 break;
912 }
913 case LITERAL_unsigned:
914 {
915 TNode tmp26_AST_in = (TNode)_t;
917 _t = _t.getNextSibling();
918 break;
919 }
920 case 27:
921 {
922 TNode tmp27_AST_in = (TNode)_t;
923 match(_t,27);
924 _t = _t.getNextSibling();
925 break;
926 }
927 case 28:
928 {
929 TNode tmp28_AST_in = (TNode)_t;
930 match(_t,28);
931 _t = _t.getNextSibling();
932 break;
933 }
934 case 29:
935 {
936 TNode tmp29_AST_in = (TNode)_t;
937 match(_t,29);
938 _t = _t.getNextSibling();
939 break;
940 }
941 case 30:
942 {
943 TNode tmp30_AST_in = (TNode)_t;
944 match(_t,30);
945 _t = _t.getNextSibling();
946 break;
947 }
948 case 31:
949 {
950 TNode tmp31_AST_in = (TNode)_t;
951 match(_t,31);
952 _t = _t.getNextSibling();
953 break;
954 }
955 case 32:
956 {
957 TNode tmp32_AST_in = (TNode)_t;
958 match(_t,32);
959 _t = _t.getNextSibling();
960 break;
961 }
962 case LITERAL_wchar_t:
963 {
964 TNode tmp33_AST_in = (TNode)_t;
966 _t = _t.getNextSibling();
967 break;
968 }
969 case 34:
970 {
971 TNode tmp34_AST_in = (TNode)_t;
972 match(_t,34);
973 _t = _t.getNextSibling();
974 break;
975 }
976 case 35:
977 {
978 TNode tmp35_AST_in = (TNode)_t;
979 match(_t,35);
980 _t = _t.getNextSibling();
981 break;
982 }
983 case 36:
984 {
985 TNode tmp36_AST_in = (TNode)_t;
986 match(_t,36);
987 _t = _t.getNextSibling();
988 break;
989 }
990 case 37:
991 {
992 TNode tmp37_AST_in = (TNode)_t;
993 match(_t,37);
994 _t = _t.getNextSibling();
995 break;
996 }
998 {
999 TNode tmp38_AST_in = (TNode)_t;
1001 _t = _t.getNextSibling();
1002 break;
1003 }
1004 case LITERAL_intptr_t:
1005 {
1006 TNode tmp39_AST_in = (TNode)_t;
1008 _t = _t.getNextSibling();
1009 break;
1010 }
1011 case LITERAL_size_t:
1012 {
1013 TNode tmp40_AST_in = (TNode)_t;
1015 _t = _t.getNextSibling();
1016 break;
1017 }
1018 case LITERAL_uintptr_t:
1019 {
1020 TNode tmp41_AST_in = (TNode)_t;
1022 _t = _t.getNextSibling();
1023 break;
1024 }
1025 case LITERAL_struct:
1026 {
1027 structSpecifier(_t);
1028 _t = _retTree;
1029 {
1030 _loop27:
1031 do {
1032 if (_t==null) _t=ASTNULL;
1033 if ((_t.getType()==NAsmAttribute||_t.getType()==LITERAL___attribute)) {
1034 attributeDecl(_t);
1035 _t = _retTree;
1036 }
1037 else {
1038 break _loop27;
1039 }
1040
1041 } while (true);
1042 }
1043 break;
1044 }
1045 case LITERAL_union:
1046 {
1047 unionSpecifier(_t);
1048 _t = _retTree;
1049 {
1050 _loop29:
1051 do {
1052 if (_t==null) _t=ASTNULL;
1053 if ((_t.getType()==NAsmAttribute||_t.getType()==LITERAL___attribute)) {
1054 attributeDecl(_t);
1055 _t = _retTree;
1056 }
1057 else {
1058 break _loop29;
1059 }
1060
1061 } while (true);
1062 }
1063 break;
1064 }
1065 case LITERAL_enum:
1066 {
1067 enumSpecifier(_t);
1068 _t = _retTree;
1069 break;
1070 }
1071 case NTypedefName:
1072 {
1073 typedefName(_t);
1074 _t = _retTree;
1075 break;
1076 }
1077 case LITERAL_typeof:
1078 {
1079 AST __t30 = _t;
1080 TNode tmp42_AST_in = (TNode)_t;
1082 _t = _t.getFirstChild();
1083 TNode tmp43_AST_in = (TNode)_t;
1084 match(_t,LPAREN);
1085 _t = _t.getNextSibling();
1086 {
1087 if (_t==null) _t=ASTNULL;
1088 switch ( _t.getType()) {
1089 case LITERAL_volatile:
1090 case LITERAL_struct:
1091 case LITERAL_union:
1092 case LITERAL_enum:
1093 case LITERAL_const:
1094 case LITERAL_void:
1095 case LITERAL_char:
1096 case LITERAL_short:
1097 case LITERAL_int:
1098 case LITERAL_long:
1099 case LITERAL_float:
1100 case LITERAL_double:
1101 case LITERAL_signed:
1102 case LITERAL_unsigned:
1103 case 27:
1104 case 28:
1105 case 29:
1106 case 30:
1107 case 31:
1108 case 32:
1109 case LITERAL_wchar_t:
1110 case 34:
1111 case 35:
1112 case 36:
1113 case 37:
1114 case LITERAL_ptrdiff_t:
1115 case LITERAL_intptr_t:
1116 case LITERAL_size_t:
1117 case LITERAL_uintptr_t:
1118 case NTypedefName:
1119 case LITERAL_typeof:
1120 case LITERAL___complex:
1121 {
1122 typeName(_t);
1123 _t = _retTree;
1124 break;
1125 }
1126 case ID:
1127 case ASSIGN:
1128 case STAR:
1129 case LPAREN:
1130 case DIV_ASSIGN:
1131 case PLUS_ASSIGN:
1132 case MINUS_ASSIGN:
1133 case STAR_ASSIGN:
1134 case MOD_ASSIGN:
1135 case RSHIFT_ASSIGN:
1136 case LSHIFT_ASSIGN:
1137 case BAND_ASSIGN:
1138 case BOR_ASSIGN:
1139 case BXOR_ASSIGN:
1140 case QUESTION:
1141 case LOR:
1142 case LAND:
1143 case BOR:
1144 case BXOR:
1145 case BAND:
1146 case EQUAL:
1147 case NOT_EQUAL:
1148 case LT:
1149 case LTE:
1150 case GT:
1151 case GTE:
1152 case LSHIFT:
1153 case RSHIFT:
1154 case PLUS:
1155 case MINUS:
1156 case DIV:
1157 case MOD:
1158 case INC:
1159 case DEC:
1160 case LITERAL_sizeof:
1161 case CharLiteral:
1162 case NCast:
1163 case NExpressionGroup:
1164 case NInitializer:
1165 case NEmptyExpression:
1166 case NCommaExpr:
1167 case NUnaryExpr:
1168 case NPostfixExpr:
1169 case NRangeExpr:
1170 case NStringSeq:
1171 case NLcurlyInitializer:
1172 case NGnuAsmExpr:
1173 case Number:
1174 case LITERAL___alignof:
1175 {
1176 expr(_t);
1177 _t = _retTree;
1178 break;
1179 }
1180 default:
1181 {
1182 throw new NoViableAltException(_t);
1183 }
1184 }
1185 }
1186 TNode tmp44_AST_in = (TNode)_t;
1187 match(_t,RPAREN);
1188 _t = _t.getNextSibling();
1189 _t = __t30;
1190 _t = _t.getNextSibling();
1191 break;
1192 }
1193 case LITERAL___complex:
1194 {
1195 TNode tmp45_AST_in = (TNode)_t;
1197 _t = _t.getNextSibling();
1198 break;
1199 }
1200 default:
1201 {
1202 throw new NoViableAltException(_t);
1203 }
1204 }
1205 }
1206 catch (RecognitionException ex) {
1207 if (inputState.guessing==0) {
1208 reportError(ex);
1209 if (_t!=null) {_t = _t.getNextSibling();}
1210 } else {
1211 throw ex;
1212 }
1213 }
1214 _retTree = _t;
1215 }
1216
1217 public final void functionStorageClassSpecifier(AST _t) throws RecognitionException {
1218
1219 TNode functionStorageClassSpecifier_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1220
1221 try { // for error handling
1222 if (_t==null) _t=ASTNULL;
1223 switch ( _t.getType()) {
1224 case LITERAL_extern:
1225 {
1226 TNode tmp46_AST_in = (TNode)_t;
1228 _t = _t.getNextSibling();
1229 break;
1230 }
1231 case LITERAL_static:
1232 {
1233 TNode tmp47_AST_in = (TNode)_t;
1235 _t = _t.getNextSibling();
1236 break;
1237 }
1238 case LITERAL_inline:
1239 {
1240 TNode tmp48_AST_in = (TNode)_t;
1242 _t = _t.getNextSibling();
1243 break;
1244 }
1245 default:
1246 {
1247 throw new NoViableAltException(_t);
1248 }
1249 }
1250 }
1251 catch (RecognitionException ex) {
1252 if (inputState.guessing==0) {
1253 reportError(ex);
1254 if (_t!=null) {_t = _t.getNextSibling();}
1255 } else {
1256 throw ex;
1257 }
1258 }
1259 _retTree = _t;
1260 }
1261
1262 public final void structSpecifier(AST _t) throws RecognitionException {
1263
1264 TNode structSpecifier_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1265
1266 try { // for error handling
1267 AST __t37 = _t;
1268 TNode tmp49_AST_in = (TNode)_t;
1270 _t = _t.getFirstChild();
1272 _t = _retTree;
1273 _t = __t37;
1274 _t = _t.getNextSibling();
1275 }
1276 catch (RecognitionException ex) {
1277 if (inputState.guessing==0) {
1278 reportError(ex);
1279 if (_t!=null) {_t = _t.getNextSibling();}
1280 } else {
1281 throw ex;
1282 }
1283 }
1284 _retTree = _t;
1285 }
1286
1287 public final void attributeDecl(AST _t) throws RecognitionException {
1288
1289 TNode attributeDecl_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1290
1291 try { // for error handling
1292 if (_t==null) _t=ASTNULL;
1293 switch ( _t.getType()) {
1295 {
1296 AST __t72 = _t;
1297 TNode tmp50_AST_in = (TNode)_t;
1299 _t = _t.getFirstChild();
1300 {
1301 _loop74:
1302 do {
1303 if (_t==null) _t=ASTNULL;
1304 if (((_t.getType() >= LITERAL_typedef && _t.getType() <= LITERAL___imag))) {
1305 TNode tmp51_AST_in = (TNode)_t;
1306 if ( _t==null ) throw new MismatchedTokenException();
1307 _t = _t.getNextSibling();
1308 }
1309 else {
1310 break _loop74;
1311 }
1312
1313 } while (true);
1314 }
1315 _t = __t72;
1316 _t = _t.getNextSibling();
1317 break;
1318 }
1319 case NAsmAttribute:
1320 {
1321 AST __t75 = _t;
1322 TNode tmp52_AST_in = (TNode)_t;
1323 match(_t,NAsmAttribute);
1324 _t = _t.getFirstChild();
1325 TNode tmp53_AST_in = (TNode)_t;
1326 match(_t,LPAREN);
1327 _t = _t.getNextSibling();
1328 expr(_t);
1329 _t = _retTree;
1330 TNode tmp54_AST_in = (TNode)_t;
1331 match(_t,RPAREN);
1332 _t = _t.getNextSibling();
1333 _t = __t75;
1334 _t = _t.getNextSibling();
1335 break;
1336 }
1337 default:
1338 {
1339 throw new NoViableAltException(_t);
1340 }
1341 }
1342 }
1343 catch (RecognitionException ex) {
1344 if (inputState.guessing==0) {
1345 reportError(ex);
1346 if (_t!=null) {_t = _t.getNextSibling();}
1347 } else {
1348 throw ex;
1349 }
1350 }
1351 _retTree = _t;
1352 }
1353
1354 public final void unionSpecifier(AST _t) throws RecognitionException {
1355
1356 TNode unionSpecifier_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1357
1358 try { // for error handling
1359 AST __t39 = _t;
1360 TNode tmp55_AST_in = (TNode)_t;
1361 match(_t,LITERAL_union);
1362 _t = _t.getFirstChild();
1364 _t = _retTree;
1365 _t = __t39;
1366 _t = _t.getNextSibling();
1367 }
1368 catch (RecognitionException ex) {
1369 if (inputState.guessing==0) {
1370 reportError(ex);
1371 if (_t!=null) {_t = _t.getNextSibling();}
1372 } else {
1373 throw ex;
1374 }
1375 }
1376 _retTree = _t;
1377 }
1378
1379 public final void enumSpecifier(AST _t) throws RecognitionException {
1380
1381 TNode enumSpecifier_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1382
1383 try { // for error handling
1384 AST __t63 = _t;
1385 TNode tmp56_AST_in = (TNode)_t;
1386 match(_t,LITERAL_enum);
1387 _t = _t.getFirstChild();
1388 {
1389 if (_t==null) _t=ASTNULL;
1390 switch ( _t.getType()) {
1391 case ID:
1392 {
1393 TNode tmp57_AST_in = (TNode)_t;
1394 match(_t,ID);
1395 _t = _t.getNextSibling();
1396 break;
1397 }
1398 case 3:
1399 case LCURLY:
1400 {
1401 break;
1402 }
1403 default:
1404 {
1405 throw new NoViableAltException(_t);
1406 }
1407 }
1408 }
1409 {
1410 if (_t==null) _t=ASTNULL;
1411 switch ( _t.getType()) {
1412 case LCURLY:
1413 {
1414 TNode tmp58_AST_in = (TNode)_t;
1415 match(_t,LCURLY);
1416 _t = _t.getNextSibling();
1417 enumList(_t);
1418 _t = _retTree;
1419 TNode tmp59_AST_in = (TNode)_t;
1420 match(_t,RCURLY);
1421 _t = _t.getNextSibling();
1422 break;
1423 }
1424 case 3:
1425 {
1426 break;
1427 }
1428 default:
1429 {
1430 throw new NoViableAltException(_t);
1431 }
1432 }
1433 }
1434 _t = __t63;
1435 _t = _t.getNextSibling();
1436 }
1437 catch (RecognitionException ex) {
1438 if (inputState.guessing==0) {
1439 reportError(ex);
1440 if (_t!=null) {_t = _t.getNextSibling();}
1441 } else {
1442 throw ex;
1443 }
1444 }
1445 _retTree = _t;
1446 }
1447
1448 public final void typedefName(AST _t) throws RecognitionException {
1449
1450 TNode typedefName_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1451
1452 try { // for error handling
1453 AST __t35 = _t;
1454 TNode tmp60_AST_in = (TNode)_t;
1455 match(_t,NTypedefName);
1456 _t = _t.getFirstChild();
1457 TNode tmp61_AST_in = (TNode)_t;
1458 match(_t,ID);
1459 _t = _t.getNextSibling();
1460 _t = __t35;
1461 _t = _t.getNextSibling();
1462 }
1463 catch (RecognitionException ex) {
1464 if (inputState.guessing==0) {
1465 reportError(ex);
1466 if (_t!=null) {_t = _t.getNextSibling();}
1467 } else {
1468 throw ex;
1469 }
1470 }
1471 _retTree = _t;
1472 }
1473
1474 public final void typeName(AST _t) throws RecognitionException {
1475
1476 TNode typeName_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1477
1478 try { // for error handling
1480 _t = _retTree;
1481 {
1482 if (_t==null) _t=ASTNULL;
1483 switch ( _t.getType()) {
1485 {
1487 _t = _retTree;
1488 break;
1489 }
1490 case RPAREN:
1491 {
1492 break;
1493 }
1494 default:
1495 {
1496 throw new NoViableAltException(_t);
1497 }
1498 }
1499 }
1500 }
1501 catch (RecognitionException ex) {
1502 if (inputState.guessing==0) {
1503 reportError(ex);
1504 if (_t!=null) {_t = _t.getNextSibling();}
1505 } else {
1506 throw ex;
1507 }
1508 }
1509 _retTree = _t;
1510 }
1511
1512 public final void structOrUnionBody(AST _t) throws RecognitionException {
1513
1514 TNode structOrUnionBody_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1515
1516 try { // for error handling
1517 {
1518 boolean synPredMatched43 = false;
1519 if (_t==null) _t=ASTNULL;
1520 if (((_t.getType()==ID))) {
1521 AST __t43 = _t;
1522 synPredMatched43 = true;
1523 inputState.guessing++;
1524 try {
1525 {
1526 TNode tmp62_AST_in = (TNode)_t;
1527 match(_t,ID);
1528 _t = _t.getNextSibling();
1529 TNode tmp63_AST_in = (TNode)_t;
1530 match(_t,LCURLY);
1531 _t = _t.getNextSibling();
1532 }
1533 }
1534 catch (RecognitionException pe) {
1535 synPredMatched43 = false;
1536 }
1537 _t = __t43;
1538inputState.guessing--;
1539 }
1540 if ( synPredMatched43 ) {
1541 TNode tmp64_AST_in = (TNode)_t;
1542 match(_t,ID);
1543 _t = _t.getNextSibling();
1544 TNode tmp65_AST_in = (TNode)_t;
1545 match(_t,LCURLY);
1546 _t = _t.getNextSibling();
1547 {
1548 if (_t==null) _t=ASTNULL;
1549 switch ( _t.getType()) {
1550 case LITERAL_volatile:
1551 case LITERAL_struct:
1552 case LITERAL_union:
1553 case LITERAL_enum:
1554 case LITERAL_const:
1555 case LITERAL_void:
1556 case LITERAL_char:
1557 case LITERAL_short:
1558 case LITERAL_int:
1559 case LITERAL_long:
1560 case LITERAL_float:
1561 case LITERAL_double:
1562 case LITERAL_signed:
1563 case LITERAL_unsigned:
1564 case 27:
1565 case 28:
1566 case 29:
1567 case 30:
1568 case 31:
1569 case 32:
1570 case LITERAL_wchar_t:
1571 case 34:
1572 case 35:
1573 case 36:
1574 case 37:
1575 case LITERAL_ptrdiff_t:
1576 case LITERAL_intptr_t:
1577 case LITERAL_size_t:
1578 case LITERAL_uintptr_t:
1579 case NTypedefName:
1580 case LITERAL_typeof:
1581 case LITERAL___complex:
1582 {
1584 _t = _retTree;
1585 break;
1586 }
1587 case RCURLY:
1588 {
1589 break;
1590 }
1591 default:
1592 {
1593 throw new NoViableAltException(_t);
1594 }
1595 }
1596 }
1597 TNode tmp66_AST_in = (TNode)_t;
1598 match(_t,RCURLY);
1599 _t = _t.getNextSibling();
1600 }
1601 else if ((_t.getType()==LCURLY)) {
1602 TNode tmp67_AST_in = (TNode)_t;
1603 match(_t,LCURLY);
1604 _t = _t.getNextSibling();
1605 {
1606 if (_t==null) _t=ASTNULL;
1607 switch ( _t.getType()) {
1608 case LITERAL_volatile:
1609 case LITERAL_struct:
1610 case LITERAL_union:
1611 case LITERAL_enum:
1612 case LITERAL_const:
1613 case LITERAL_void:
1614 case LITERAL_char:
1615 case LITERAL_short:
1616 case LITERAL_int:
1617 case LITERAL_long:
1618 case LITERAL_float:
1619 case LITERAL_double:
1620 case LITERAL_signed:
1621 case LITERAL_unsigned:
1622 case 27:
1623 case 28:
1624 case 29:
1625 case 30:
1626 case 31:
1627 case 32:
1628 case LITERAL_wchar_t:
1629 case 34:
1630 case 35:
1631 case 36:
1632 case 37:
1633 case LITERAL_ptrdiff_t:
1634 case LITERAL_intptr_t:
1635 case LITERAL_size_t:
1636 case LITERAL_uintptr_t:
1637 case NTypedefName:
1638 case LITERAL_typeof:
1639 case LITERAL___complex:
1640 {
1642 _t = _retTree;
1643 break;
1644 }
1645 case RCURLY:
1646 {
1647 break;
1648 }
1649 default:
1650 {
1651 throw new NoViableAltException(_t);
1652 }
1653 }
1654 }
1655 TNode tmp68_AST_in = (TNode)_t;
1656 match(_t,RCURLY);
1657 _t = _t.getNextSibling();
1658 }
1659 else if ((_t.getType()==ID)) {
1660 TNode tmp69_AST_in = (TNode)_t;
1661 match(_t,ID);
1662 _t = _t.getNextSibling();
1663 }
1664 else {
1665 throw new NoViableAltException(_t);
1666 }
1667
1668 }
1669 }
1670 catch (RecognitionException ex) {
1671 if (inputState.guessing==0) {
1672 reportError(ex);
1673 if (_t!=null) {_t = _t.getNextSibling();}
1674 } else {
1675 throw ex;
1676 }
1677 }
1678 _retTree = _t;
1679 }
1680
1681 public final void structDeclarationList(AST _t) throws RecognitionException {
1682
1683 TNode structDeclarationList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1684
1685 try { // for error handling
1686 {
1687 int _cnt48=0;
1688 _loop48:
1689 do {
1690 if (_t==null) _t=ASTNULL;
1691 if ((_tokenSet_1.member(_t.getType()))) {
1693 _t = _retTree;
1694 }
1695 else {
1696 if ( _cnt48>=1 ) { break _loop48; } else {throw new NoViableAltException(_t);}
1697 }
1698
1699 _cnt48++;
1700 } while (true);
1701 }
1702 }
1703 catch (RecognitionException ex) {
1704 if (inputState.guessing==0) {
1705 reportError(ex);
1706 if (_t!=null) {_t = _t.getNextSibling();}
1707 } else {
1708 throw ex;
1709 }
1710 }
1711 _retTree = _t;
1712 }
1713
1714 public final void structDeclaration(AST _t) throws RecognitionException {
1715
1716 TNode structDeclaration_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1717
1718 try { // for error handling
1720 _t = _retTree;
1722 _t = _retTree;
1723 }
1724 catch (RecognitionException ex) {
1725 if (inputState.guessing==0) {
1726 reportError(ex);
1727 if (_t!=null) {_t = _t.getNextSibling();}
1728 } else {
1729 throw ex;
1730 }
1731 }
1732 _retTree = _t;
1733 }
1734
1735 public final void specifierQualifierList(AST _t) throws RecognitionException {
1736
1737 TNode specifierQualifierList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1738
1739 try { // for error handling
1740 {
1741 int _cnt52=0;
1742 _loop52:
1743 do {
1744 if (_t==null) _t=ASTNULL;
1745 switch ( _t.getType()) {
1746 case LITERAL_struct:
1747 case LITERAL_union:
1748 case LITERAL_enum:
1749 case LITERAL_void:
1750 case LITERAL_char:
1751 case LITERAL_short:
1752 case LITERAL_int:
1753 case LITERAL_long:
1754 case LITERAL_float:
1755 case LITERAL_double:
1756 case LITERAL_signed:
1757 case LITERAL_unsigned:
1758 case 27:
1759 case 28:
1760 case 29:
1761 case 30:
1762 case 31:
1763 case 32:
1764 case LITERAL_wchar_t:
1765 case 34:
1766 case 35:
1767 case 36:
1768 case 37:
1769 case LITERAL_ptrdiff_t:
1770 case LITERAL_intptr_t:
1771 case LITERAL_size_t:
1772 case LITERAL_uintptr_t:
1773 case NTypedefName:
1774 case LITERAL_typeof:
1775 case LITERAL___complex:
1776 {
1777 typeSpecifier(_t);
1778 _t = _retTree;
1779 break;
1780 }
1781 case LITERAL_volatile:
1782 case LITERAL_const:
1783 {
1784 typeQualifier(_t);
1785 _t = _retTree;
1786 break;
1787 }
1788 default:
1789 {
1790 if ( _cnt52>=1 ) { break _loop52; } else {throw new NoViableAltException(_t);}
1791 }
1792 }
1793 _cnt52++;
1794 } while (true);
1795 }
1796 }
1797 catch (RecognitionException ex) {
1798 if (inputState.guessing==0) {
1799 reportError(ex);
1800 if (_t!=null) {_t = _t.getNextSibling();}
1801 } else {
1802 throw ex;
1803 }
1804 }
1805 _retTree = _t;
1806 }
1807
1808 public final void structDeclaratorList(AST _t) throws RecognitionException {
1809
1810 TNode structDeclaratorList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1811
1812 try { // for error handling
1813 {
1814 int _cnt55=0;
1815 _loop55:
1816 do {
1817 if (_t==null) _t=ASTNULL;
1818 if ((_t.getType()==NStructDeclarator)) {
1819 structDeclarator(_t);
1820 _t = _retTree;
1821 }
1822 else {
1823 if ( _cnt55>=1 ) { break _loop55; } else {throw new NoViableAltException(_t);}
1824 }
1825
1826 _cnt55++;
1827 } while (true);
1828 }
1829 }
1830 catch (RecognitionException ex) {
1831 if (inputState.guessing==0) {
1832 reportError(ex);
1833 if (_t!=null) {_t = _t.getNextSibling();}
1834 } else {
1835 throw ex;
1836 }
1837 }
1838 _retTree = _t;
1839 }
1840
1841 public final void structDeclarator(AST _t) throws RecognitionException {
1842
1843 TNode structDeclarator_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1844
1845 try { // for error handling
1846 AST __t57 = _t;
1847 TNode tmp70_AST_in = (TNode)_t;
1849 _t = _t.getFirstChild();
1850 {
1851 if (_t==null) _t=ASTNULL;
1852 switch ( _t.getType()) {
1853 case NDeclarator:
1854 {
1855 declarator(_t);
1856 _t = _retTree;
1857 break;
1858 }
1859 case 3:
1860 case COLON:
1861 case NAsmAttribute:
1863 {
1864 break;
1865 }
1866 default:
1867 {
1868 throw new NoViableAltException(_t);
1869 }
1870 }
1871 }
1872 {
1873 if (_t==null) _t=ASTNULL;
1874 switch ( _t.getType()) {
1875 case COLON:
1876 {
1877 TNode tmp71_AST_in = (TNode)_t;
1878 match(_t,COLON);
1879 _t = _t.getNextSibling();
1880 expr(_t);
1881 _t = _retTree;
1882 break;
1883 }
1884 case 3:
1885 case NAsmAttribute:
1887 {
1888 break;
1889 }
1890 default:
1891 {
1892 throw new NoViableAltException(_t);
1893 }
1894 }
1895 }
1896 {
1897 _loop61:
1898 do {
1899 if (_t==null) _t=ASTNULL;
1900 if ((_t.getType()==NAsmAttribute||_t.getType()==LITERAL___attribute)) {
1901 attributeDecl(_t);
1902 _t = _retTree;
1903 }
1904 else {
1905 break _loop61;
1906 }
1907
1908 } while (true);
1909 }
1910 _t = __t57;
1911 _t = _t.getNextSibling();
1912 }
1913 catch (RecognitionException ex) {
1914 if (inputState.guessing==0) {
1915 reportError(ex);
1916 if (_t!=null) {_t = _t.getNextSibling();}
1917 } else {
1918 throw ex;
1919 }
1920 }
1921 _retTree = _t;
1922 }
1923
1924 public final void declarator(AST _t) throws RecognitionException {
1925
1926 TNode declarator_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
1927 TNode id = null;
1928
1929 try { // for error handling
1930 AST __t107 = _t;
1931 TNode tmp72_AST_in = (TNode)_t;
1932 match(_t,NDeclarator);
1933 _t = _t.getFirstChild();
1934 {
1935 if (_t==null) _t=ASTNULL;
1936 switch ( _t.getType()) {
1937 case NPointerGroup:
1938 {
1939 pointerGroup(_t);
1940 _t = _retTree;
1941 break;
1942 }
1943 case ID:
1944 case LPAREN:
1945 {
1946 break;
1947 }
1948 default:
1949 {
1950 throw new NoViableAltException(_t);
1951 }
1952 }
1953 }
1954 {
1955 if (_t==null) _t=ASTNULL;
1956 switch ( _t.getType()) {
1957 case ID:
1958 {
1959 id = (TNode)_t;
1960 match(_t,ID);
1961 _t = _t.getNextSibling();
1962 break;
1963 }
1964 case LPAREN:
1965 {
1966 TNode tmp73_AST_in = (TNode)_t;
1967 match(_t,LPAREN);
1968 _t = _t.getNextSibling();
1969 declarator(_t);
1970 _t = _retTree;
1971 TNode tmp74_AST_in = (TNode)_t;
1972 match(_t,RPAREN);
1973 _t = _t.getNextSibling();
1974 break;
1975 }
1976 default:
1977 {
1978 throw new NoViableAltException(_t);
1979 }
1980 }
1981 }
1982 {
1983 _loop115:
1984 do {
1985 if (_t==null) _t=ASTNULL;
1986 switch ( _t.getType()) {
1987 case NParameterTypeList:
1988 {
1989 AST __t111 = _t;
1990 TNode tmp75_AST_in = (TNode)_t;
1992 _t = _t.getFirstChild();
1993 {
1994 if (_t==null) _t=ASTNULL;
1995 switch ( _t.getType()) {
1997 {
1999 _t = _retTree;
2000 break;
2001 }
2002 case ID:
2003 case RPAREN:
2004 {
2005 {
2006 if (_t==null) _t=ASTNULL;
2007 switch ( _t.getType()) {
2008 case ID:
2009 {
2010 idList(_t);
2011 _t = _retTree;
2012 break;
2013 }
2014 case RPAREN:
2015 {
2016 break;
2017 }
2018 default:
2019 {
2020 throw new NoViableAltException(_t);
2021 }
2022 }
2023 }
2024 break;
2025 }
2026 default:
2027 {
2028 throw new NoViableAltException(_t);
2029 }
2030 }
2031 }
2032 TNode tmp76_AST_in = (TNode)_t;
2033 match(_t,RPAREN);
2034 _t = _t.getNextSibling();
2035 _t = __t111;
2036 _t = _t.getNextSibling();
2037 break;
2038 }
2039 case LBRACKET:
2040 {
2041 TNode tmp77_AST_in = (TNode)_t;
2042 match(_t,LBRACKET);
2043 _t = _t.getNextSibling();
2044 {
2045 if (_t==null) _t=ASTNULL;
2046 switch ( _t.getType()) {
2047 case ID:
2048 case ASSIGN:
2049 case STAR:
2050 case LPAREN:
2051 case DIV_ASSIGN:
2052 case PLUS_ASSIGN:
2053 case MINUS_ASSIGN:
2054 case STAR_ASSIGN:
2055 case MOD_ASSIGN:
2056 case RSHIFT_ASSIGN:
2057 case LSHIFT_ASSIGN:
2058 case BAND_ASSIGN:
2059 case BOR_ASSIGN:
2060 case BXOR_ASSIGN:
2061 case QUESTION:
2062 case LOR:
2063 case LAND:
2064 case BOR:
2065 case BXOR:
2066 case BAND:
2067 case EQUAL:
2068 case NOT_EQUAL:
2069 case LT:
2070 case LTE:
2071 case GT:
2072 case GTE:
2073 case LSHIFT:
2074 case RSHIFT:
2075 case PLUS:
2076 case MINUS:
2077 case DIV:
2078 case MOD:
2079 case INC:
2080 case DEC:
2081 case LITERAL_sizeof:
2082 case CharLiteral:
2083 case NCast:
2084 case NExpressionGroup:
2085 case NInitializer:
2086 case NEmptyExpression:
2087 case NCommaExpr:
2088 case NUnaryExpr:
2089 case NPostfixExpr:
2090 case NRangeExpr:
2091 case NStringSeq:
2092 case NLcurlyInitializer:
2093 case NGnuAsmExpr:
2094 case Number:
2095 case LITERAL___alignof:
2096 {
2097 expr(_t);
2098 _t = _retTree;
2099 break;
2100 }
2101 case RBRACKET:
2102 {
2103 break;
2104 }
2105 default:
2106 {
2107 throw new NoViableAltException(_t);
2108 }
2109 }
2110 }
2111 TNode tmp78_AST_in = (TNode)_t;
2112 match(_t,RBRACKET);
2113 _t = _t.getNextSibling();
2114 break;
2115 }
2116 default:
2117 {
2118 break _loop115;
2119 }
2120 }
2121 } while (true);
2122 }
2123 _t = __t107;
2124 _t = _t.getNextSibling();
2125 }
2126 catch (RecognitionException ex) {
2127 if (inputState.guessing==0) {
2128 reportError(ex);
2129 if (_t!=null) {_t = _t.getNextSibling();}
2130 } else {
2131 throw ex;
2132 }
2133 }
2134 _retTree = _t;
2135 }
2136
2137 public final void enumList(AST _t) throws RecognitionException {
2138
2139 TNode enumList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2140
2141 try { // for error handling
2142 {
2143 int _cnt68=0;
2144 _loop68:
2145 do {
2146 if (_t==null) _t=ASTNULL;
2147 if ((_t.getType()==ID)) {
2148 enumerator(_t);
2149 _t = _retTree;
2150 }
2151 else {
2152 if ( _cnt68>=1 ) { break _loop68; } else {throw new NoViableAltException(_t);}
2153 }
2154
2155 _cnt68++;
2156 } while (true);
2157 }
2158 }
2159 catch (RecognitionException ex) {
2160 if (inputState.guessing==0) {
2161 reportError(ex);
2162 if (_t!=null) {_t = _t.getNextSibling();}
2163 } else {
2164 throw ex;
2165 }
2166 }
2167 _retTree = _t;
2168 }
2169
2170 public final void enumerator(AST _t) throws RecognitionException {
2171
2172 TNode enumerator_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2173
2174 try { // for error handling
2175 TNode tmp79_AST_in = (TNode)_t;
2176 match(_t,ID);
2177 _t = _t.getNextSibling();
2178 {
2179 if (_t==null) _t=ASTNULL;
2180 switch ( _t.getType()) {
2181 case ASSIGN:
2182 {
2183 TNode tmp80_AST_in = (TNode)_t;
2184 match(_t,ASSIGN);
2185 _t = _t.getNextSibling();
2186 expr(_t);
2187 _t = _retTree;
2188 break;
2189 }
2190 case RCURLY:
2191 case ID:
2192 {
2193 break;
2194 }
2195 default:
2196 {
2197 throw new NoViableAltException(_t);
2198 }
2199 }
2200 }
2201 }
2202 catch (RecognitionException ex) {
2203 if (inputState.guessing==0) {
2204 reportError(ex);
2205 if (_t!=null) {_t = _t.getNextSibling();}
2206 } else {
2207 throw ex;
2208 }
2209 }
2210 _retTree = _t;
2211 }
2212
2213 public final void initDecl(AST _t) throws RecognitionException {
2214
2215 TNode initDecl_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2216 String declName = "";
2217
2218 try { // for error handling
2219 AST __t80 = _t;
2220 TNode tmp81_AST_in = (TNode)_t;
2221 match(_t,NInitDecl);
2222 _t = _t.getFirstChild();
2223 declarator(_t);
2224 _t = _retTree;
2225 {
2226 _loop82:
2227 do {
2228 if (_t==null) _t=ASTNULL;
2229 if ((_t.getType()==NAsmAttribute||_t.getType()==LITERAL___attribute)) {
2230 attributeDecl(_t);
2231 _t = _retTree;
2232 }
2233 else {
2234 break _loop82;
2235 }
2236
2237 } while (true);
2238 }
2239 {
2240 if (_t==null) _t=ASTNULL;
2241 switch ( _t.getType()) {
2242 case ASSIGN:
2243 {
2244 TNode tmp82_AST_in = (TNode)_t;
2245 match(_t,ASSIGN);
2246 _t = _t.getNextSibling();
2247 initializer(_t);
2248 _t = _retTree;
2249 break;
2250 }
2251 case COLON:
2252 {
2253 TNode tmp83_AST_in = (TNode)_t;
2254 match(_t,COLON);
2255 _t = _t.getNextSibling();
2256 expr(_t);
2257 _t = _retTree;
2258 break;
2259 }
2260 case 3:
2261 {
2262 break;
2263 }
2264 default:
2265 {
2266 throw new NoViableAltException(_t);
2267 }
2268 }
2269 }
2270 _t = __t80;
2271 _t = _t.getNextSibling();
2272 }
2273 catch (RecognitionException ex) {
2274 if (inputState.guessing==0) {
2275 reportError(ex);
2276 if (_t!=null) {_t = _t.getNextSibling();}
2277 } else {
2278 throw ex;
2279 }
2280 }
2281 _retTree = _t;
2282 }
2283
2284 public final void initializer(AST _t) throws RecognitionException {
2285
2286 TNode initializer_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2287
2288 try { // for error handling
2289 if (_t==null) _t=ASTNULL;
2290 switch ( _t.getType()) {
2291 case NInitializer:
2292 {
2293 AST __t94 = _t;
2294 TNode tmp84_AST_in = (TNode)_t;
2295 match(_t,NInitializer);
2296 _t = _t.getFirstChild();
2297 {
2298 if (_t==null) _t=ASTNULL;
2299 switch ( _t.getType()) {
2301 {
2303 _t = _retTree;
2304 break;
2305 }
2306 case ID:
2307 case ASSIGN:
2308 case STAR:
2309 case LPAREN:
2310 case DIV_ASSIGN:
2311 case PLUS_ASSIGN:
2312 case MINUS_ASSIGN:
2313 case STAR_ASSIGN:
2314 case MOD_ASSIGN:
2315 case RSHIFT_ASSIGN:
2316 case LSHIFT_ASSIGN:
2317 case BAND_ASSIGN:
2318 case BOR_ASSIGN:
2319 case BXOR_ASSIGN:
2320 case QUESTION:
2321 case LOR:
2322 case LAND:
2323 case BOR:
2324 case BXOR:
2325 case BAND:
2326 case EQUAL:
2327 case NOT_EQUAL:
2328 case LT:
2329 case LTE:
2330 case GT:
2331 case GTE:
2332 case LSHIFT:
2333 case RSHIFT:
2334 case PLUS:
2335 case MINUS:
2336 case DIV:
2337 case MOD:
2338 case INC:
2339 case DEC:
2340 case LITERAL_sizeof:
2341 case CharLiteral:
2342 case NCast:
2343 case NExpressionGroup:
2344 case NInitializer:
2345 case NEmptyExpression:
2346 case NCommaExpr:
2347 case NUnaryExpr:
2348 case NPostfixExpr:
2349 case NRangeExpr:
2350 case NStringSeq:
2351 case NLcurlyInitializer:
2352 case NGnuAsmExpr:
2353 case Number:
2354 case LITERAL___alignof:
2355 {
2356 break;
2357 }
2358 default:
2359 {
2360 throw new NoViableAltException(_t);
2361 }
2362 }
2363 }
2364 expr(_t);
2365 _t = _retTree;
2366 _t = __t94;
2367 _t = _t.getNextSibling();
2368 break;
2369 }
2370 case NLcurlyInitializer:
2371 {
2373 _t = _retTree;
2374 break;
2375 }
2376 default:
2377 {
2378 throw new NoViableAltException(_t);
2379 }
2380 }
2381 }
2382 catch (RecognitionException ex) {
2383 if (inputState.guessing==0) {
2384 reportError(ex);
2385 if (_t!=null) {_t = _t.getNextSibling();}
2386 } else {
2387 throw ex;
2388 }
2389 }
2390 _retTree = _t;
2391 }
2392
2393 public final void pointerGroup(AST _t) throws RecognitionException {
2394
2395 TNode pointerGroup_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2396
2397 try { // for error handling
2398 AST __t85 = _t;
2399 TNode tmp85_AST_in = (TNode)_t;
2400 match(_t,NPointerGroup);
2401 _t = _t.getFirstChild();
2402 {
2403 int _cnt89=0;
2404 _loop89:
2405 do {
2406 if (_t==null) _t=ASTNULL;
2407 if ((_t.getType()==STAR)) {
2408 TNode tmp86_AST_in = (TNode)_t;
2409 match(_t,STAR);
2410 _t = _t.getNextSibling();
2411 {
2412 _loop88:
2413 do {
2414 if (_t==null) _t=ASTNULL;
2415 if ((_t.getType()==LITERAL_volatile||_t.getType()==LITERAL_const)) {
2416 typeQualifier(_t);
2417 _t = _retTree;
2418 }
2419 else {
2420 break _loop88;
2421 }
2422
2423 } while (true);
2424 }
2425 }
2426 else {
2427 if ( _cnt89>=1 ) { break _loop89; } else {throw new NoViableAltException(_t);}
2428 }
2429
2430 _cnt89++;
2431 } while (true);
2432 }
2433 _t = __t85;
2434 _t = _t.getNextSibling();
2435 }
2436 catch (RecognitionException ex) {
2437 if (inputState.guessing==0) {
2438 reportError(ex);
2439 if (_t!=null) {_t = _t.getNextSibling();}
2440 } else {
2441 throw ex;
2442 }
2443 }
2444 _retTree = _t;
2445 }
2446
2447 public final void idList(AST _t) throws RecognitionException {
2448
2449 TNode idList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2450
2451 try { // for error handling
2452 TNode tmp87_AST_in = (TNode)_t;
2453 match(_t,ID);
2454 _t = _t.getNextSibling();
2455 {
2456 _loop92:
2457 do {
2458 if (_t==null) _t=ASTNULL;
2459 if ((_t.getType()==COMMA)) {
2460 TNode tmp88_AST_in = (TNode)_t;
2461 match(_t,COMMA);
2462 _t = _t.getNextSibling();
2463 TNode tmp89_AST_in = (TNode)_t;
2464 match(_t,ID);
2465 _t = _t.getNextSibling();
2466 }
2467 else {
2468 break _loop92;
2469 }
2470
2471 } while (true);
2472 }
2473 }
2474 catch (RecognitionException ex) {
2475 if (inputState.guessing==0) {
2476 reportError(ex);
2477 if (_t!=null) {_t = _t.getNextSibling();}
2478 } else {
2479 throw ex;
2480 }
2481 }
2482 _retTree = _t;
2483 }
2484
2485 public final void initializerElementLabel(AST _t) throws RecognitionException {
2486
2487 TNode initializerElementLabel_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2488
2489 try { // for error handling
2490 AST __t97 = _t;
2491 TNode tmp90_AST_in = (TNode)_t;
2493 _t = _t.getFirstChild();
2494 {
2495 if (_t==null) _t=ASTNULL;
2496 switch ( _t.getType()) {
2497 case LBRACKET:
2498 {
2499 {
2500 TNode tmp91_AST_in = (TNode)_t;
2501 match(_t,LBRACKET);
2502 _t = _t.getNextSibling();
2503 expr(_t);
2504 _t = _retTree;
2505 TNode tmp92_AST_in = (TNode)_t;
2506 match(_t,RBRACKET);
2507 _t = _t.getNextSibling();
2508 {
2509 if (_t==null) _t=ASTNULL;
2510 switch ( _t.getType()) {
2511 case ASSIGN:
2512 {
2513 TNode tmp93_AST_in = (TNode)_t;
2514 match(_t,ASSIGN);
2515 _t = _t.getNextSibling();
2516 break;
2517 }
2518 case 3:
2519 {
2520 break;
2521 }
2522 default:
2523 {
2524 throw new NoViableAltException(_t);
2525 }
2526 }
2527 }
2528 }
2529 break;
2530 }
2531 case ID:
2532 {
2533 TNode tmp94_AST_in = (TNode)_t;
2534 match(_t,ID);
2535 _t = _t.getNextSibling();
2536 TNode tmp95_AST_in = (TNode)_t;
2537 match(_t,COLON);
2538 _t = _t.getNextSibling();
2539 break;
2540 }
2541 case DOT:
2542 {
2543 TNode tmp96_AST_in = (TNode)_t;
2544 match(_t,DOT);
2545 _t = _t.getNextSibling();
2546 TNode tmp97_AST_in = (TNode)_t;
2547 match(_t,ID);
2548 _t = _t.getNextSibling();
2549 TNode tmp98_AST_in = (TNode)_t;
2550 match(_t,ASSIGN);
2551 _t = _t.getNextSibling();
2552 break;
2553 }
2554 default:
2555 {
2556 throw new NoViableAltException(_t);
2557 }
2558 }
2559 }
2560 _t = __t97;
2561 _t = _t.getNextSibling();
2562 }
2563 catch (RecognitionException ex) {
2564 if (inputState.guessing==0) {
2565 reportError(ex);
2566 if (_t!=null) {_t = _t.getNextSibling();}
2567 } else {
2568 throw ex;
2569 }
2570 }
2571 _retTree = _t;
2572 }
2573
2574 public final void lcurlyInitializer(AST _t) throws RecognitionException {
2575
2576 TNode lcurlyInitializer_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2577
2578 try { // for error handling
2579 AST __t102 = _t;
2580 TNode tmp99_AST_in = (TNode)_t;
2582 _t = _t.getFirstChild();
2583 initializerList(_t);
2584 _t = _retTree;
2585 TNode tmp100_AST_in = (TNode)_t;
2586 match(_t,RCURLY);
2587 _t = _t.getNextSibling();
2588 _t = __t102;
2589 _t = _t.getNextSibling();
2590 }
2591 catch (RecognitionException ex) {
2592 if (inputState.guessing==0) {
2593 reportError(ex);
2594 if (_t!=null) {_t = _t.getNextSibling();}
2595 } else {
2596 throw ex;
2597 }
2598 }
2599 _retTree = _t;
2600 }
2601
2602 public final void initializerList(AST _t) throws RecognitionException {
2603
2604 TNode initializerList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2605
2606 try { // for error handling
2607 {
2608 _loop105:
2609 do {
2610 if (_t==null) _t=ASTNULL;
2611 if ((_t.getType()==NInitializer||_t.getType()==NLcurlyInitializer)) {
2612 initializer(_t);
2613 _t = _retTree;
2614 }
2615 else {
2616 break _loop105;
2617 }
2618
2619 } while (true);
2620 }
2621 }
2622 catch (RecognitionException ex) {
2623 if (inputState.guessing==0) {
2624 reportError(ex);
2625 if (_t!=null) {_t = _t.getNextSibling();}
2626 } else {
2627 throw ex;
2628 }
2629 }
2630 _retTree = _t;
2631 }
2632
2633 public final void parameterTypeList(AST _t) throws RecognitionException {
2634
2635 TNode parameterTypeList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2636
2637 try { // for error handling
2638 {
2639 int _cnt119=0;
2640 _loop119:
2641 do {
2642 if (_t==null) _t=ASTNULL;
2643 if ((_t.getType()==NParameterDeclaration)) {
2645 _t = _retTree;
2646 {
2647 if (_t==null) _t=ASTNULL;
2648 switch ( _t.getType()) {
2649 case COMMA:
2650 {
2651 TNode tmp101_AST_in = (TNode)_t;
2652 match(_t,COMMA);
2653 _t = _t.getNextSibling();
2654 break;
2655 }
2656 case SEMI:
2657 {
2658 TNode tmp102_AST_in = (TNode)_t;
2659 match(_t,SEMI);
2660 _t = _t.getNextSibling();
2661 break;
2662 }
2663 case RPAREN:
2664 case VARARGS:
2666 {
2667 break;
2668 }
2669 default:
2670 {
2671 throw new NoViableAltException(_t);
2672 }
2673 }
2674 }
2675 }
2676 else {
2677 if ( _cnt119>=1 ) { break _loop119; } else {throw new NoViableAltException(_t);}
2678 }
2679
2680 _cnt119++;
2681 } while (true);
2682 }
2683 {
2684 if (_t==null) _t=ASTNULL;
2685 switch ( _t.getType()) {
2686 case VARARGS:
2687 {
2688 TNode tmp103_AST_in = (TNode)_t;
2689 match(_t,VARARGS);
2690 _t = _t.getNextSibling();
2691 break;
2692 }
2693 case RPAREN:
2694 {
2695 break;
2696 }
2697 default:
2698 {
2699 throw new NoViableAltException(_t);
2700 }
2701 }
2702 }
2703 }
2704 catch (RecognitionException ex) {
2705 if (inputState.guessing==0) {
2706 reportError(ex);
2707 if (_t!=null) {_t = _t.getNextSibling();}
2708 } else {
2709 throw ex;
2710 }
2711 }
2712 _retTree = _t;
2713 }
2714
2715 public final void parameterDeclaration(AST _t) throws RecognitionException {
2716
2717 TNode parameterDeclaration_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2718
2719 try { // for error handling
2720 AST __t122 = _t;
2721 TNode tmp104_AST_in = (TNode)_t;
2723 _t = _t.getFirstChild();
2724 declSpecifiers(_t);
2725 _t = _retTree;
2726 {
2727 if (_t==null) _t=ASTNULL;
2728 switch ( _t.getType()) {
2729 case NDeclarator:
2730 {
2731 declarator(_t);
2732 _t = _retTree;
2733 break;
2734 }
2736 {
2738 _t = _retTree;
2739 break;
2740 }
2741 case 3:
2742 {
2743 break;
2744 }
2745 default:
2746 {
2747 throw new NoViableAltException(_t);
2748 }
2749 }
2750 }
2751 _t = __t122;
2752 _t = _t.getNextSibling();
2753 }
2754 catch (RecognitionException ex) {
2755 if (inputState.guessing==0) {
2756 reportError(ex);
2757 if (_t!=null) {_t = _t.getNextSibling();}
2758 } else {
2759 throw ex;
2760 }
2761 }
2762 _retTree = _t;
2763 }
2764
2765 public final void nonemptyAbstractDeclarator(AST _t) throws RecognitionException {
2766
2767 TNode nonemptyAbstractDeclarator_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
2768
2769 try { // for error handling
2770 AST __t237 = _t;
2771 TNode tmp105_AST_in = (TNode)_t;
2773 _t = _t.getFirstChild();
2774 {
2775 if (_t==null) _t=ASTNULL;
2776 switch ( _t.getType()) {
2777 case NPointerGroup:
2778 {
2779 pointerGroup(_t);
2780 _t = _retTree;
2781 {
2782 _loop244:
2783 do {
2784 if (_t==null) _t=ASTNULL;
2785 switch ( _t.getType()) {
2786 case LPAREN:
2787 {
2788 {
2789 TNode tmp106_AST_in = (TNode)_t;
2790 match(_t,LPAREN);
2791 _t = _t.getNextSibling();
2792 {
2793 if (_t==null) _t=ASTNULL;
2794 switch ( _t.getType()) {
2796 {
2798 _t = _retTree;
2799 break;
2800 }
2802 {
2804 _t = _retTree;
2805 break;
2806 }
2807 case RPAREN:
2808 {
2809 break;
2810 }
2811 default:
2812 {
2813 throw new NoViableAltException(_t);
2814 }
2815 }
2816 }
2817 TNode tmp107_AST_in = (TNode)_t;
2818 match(_t,RPAREN);
2819 _t = _t.getNextSibling();
2820 }
2821 break;
2822 }
2823 case LBRACKET:
2824 {
2825 {
2826 TNode tmp108_AST_in = (TNode)_t;
2827 match(_t,LBRACKET);
2828 _t = _t.getNextSibling();
2829 {
2830 if (_t==null) _t=ASTNULL;
2831 switch ( _t.getType()) {
2832 case ID:
2833 case ASSIGN:
2834 case STAR:
2835 case LPAREN:
2836 case DIV_ASSIGN:
2837 case PLUS_ASSIGN:
2838 case MINUS_ASSIGN:
2839 case STAR_ASSIGN:
2840 case MOD_ASSIGN:
2841 case RSHIFT_ASSIGN:
2842 case LSHIFT_ASSIGN:
2843 case BAND_ASSIGN:
2844 case BOR_ASSIGN:
2845 case BXOR_ASSIGN:
2846 case QUESTION:
2847 case LOR:
2848 case LAND:
2849 case BOR:
2850 case BXOR:
2851 case BAND:
2852 case EQUAL:
2853 case NOT_EQUAL:
2854 case LT:
2855 case LTE:
2856 case GT:
2857 case GTE:
2858 case LSHIFT:
2859 case RSHIFT:
2860 case PLUS:
2861 case MINUS:
2862 case DIV:
2863 case MOD:
2864 case INC:
2865 case DEC:
2866 case LITERAL_sizeof:
2867 case CharLiteral:
2868 case NCast:
2869 case NExpressionGroup:
2870 case NInitializer:
2871 case NEmptyExpression:
2872 case NCommaExpr:
2873 case NUnaryExpr:
2874 case NPostfixExpr:
2875 case NRangeExpr:
2876 case NStringSeq:
2877 case NLcurlyInitializer:
2878 case NGnuAsmExpr:
2879 case Number:
2880 case LITERAL___alignof:
2881 {
2882 expr(_t);
2883 _t = _retTree;
2884 break;
2885 }
2886 case RBRACKET:
2887 {
2888 break;
2889 }
2890 default:
2891 {
2892 throw new NoViableAltException(_t);
2893 }
2894 }
2895 }
2896 TNode tmp109_AST_in = (TNode)_t;
2897 match(_t,RBRACKET);
2898 _t = _t.getNextSibling();
2899 }
2900 break;
2901 }
2902 default:
2903 {
2904 break _loop244;
2905 }
2906 }
2907 } while (true);
2908 }
2909 break;
2910 }
2911 case LPAREN:
2912 case LBRACKET:
2913 {
2914 {
2915 int _cnt250=0;
2916 _loop250:
2917 do {
2918 if (_t==null) _t=ASTNULL;
2919 switch ( _t.getType()) {
2920 case LPAREN:
2921 {
2922 {
2923 TNode tmp110_AST_in = (TNode)_t;
2924 match(_t,LPAREN);
2925 _t = _t.getNextSibling();
2926 {
2927 if (_t==null) _t=ASTNULL;
2928 switch ( _t.getType()) {
2930 {
2932 _t = _retTree;
2933 break;
2934 }
2936 {
2938 _t = _retTree;
2939 break;
2940 }
2941 case RPAREN:
2942 {
2943 break;
2944 }
2945 default:
2946 {
2947 throw new NoViableAltException(_t);
2948 }
2949 }
2950 }
2951 TNode tmp111_AST_in = (TNode)_t;
2952 match(_t,RPAREN);
2953 _t = _t.getNextSibling();
2954 }
2955 break;
2956 }
2957 case LBRACKET:
2958 {
2959 {
2960 TNode tmp112_AST_in = (TNode)_t;
2961 match(_t,LBRACKET);
2962 _t = _t.getNextSibling();
2963 {
2964 if (_t==null) _t=ASTNULL;
2965 switch ( _t.getType()) {
2966 case ID:
2967 case ASSIGN:
2968 case STAR:
2969 case LPAREN:
2970 case DIV_ASSIGN:
2971 case PLUS_ASSIGN:
2972 case MINUS_ASSIGN:
2973 case STAR_ASSIGN:
2974 case MOD_ASSIGN:
2975 case RSHIFT_ASSIGN:
2976 case LSHIFT_ASSIGN:
2977 case BAND_ASSIGN:
2978 case BOR_ASSIGN:
2979 case BXOR_ASSIGN:
2980 case QUESTION:
2981 case LOR:
2982 case LAND:
2983 case BOR:
2984 case BXOR:
2985 case BAND:
2986 case EQUAL:
2987 case NOT_EQUAL:
2988 case LT:
2989 case LTE:
2990 case GT:
2991 case GTE:
2992 case LSHIFT:
2993 case RSHIFT:
2994 case PLUS:
2995 case MINUS:
2996 case DIV:
2997 case MOD:
2998 case INC:
2999 case DEC:
3000 case LITERAL_sizeof:
3001 case CharLiteral:
3002 case NCast:
3003 case NExpressionGroup:
3004 case NInitializer:
3005 case NEmptyExpression:
3006 case NCommaExpr:
3007 case NUnaryExpr:
3008 case NPostfixExpr:
3009 case NRangeExpr:
3010 case NStringSeq:
3011 case NLcurlyInitializer:
3012 case NGnuAsmExpr:
3013 case Number:
3014 case LITERAL___alignof:
3015 {
3016 expr(_t);
3017 _t = _retTree;
3018 break;
3019 }
3020 case RBRACKET:
3021 {
3022 break;
3023 }
3024 default:
3025 {
3026 throw new NoViableAltException(_t);
3027 }
3028 }
3029 }
3030 TNode tmp113_AST_in = (TNode)_t;
3031 match(_t,RBRACKET);
3032 _t = _t.getNextSibling();
3033 }
3034 break;
3035 }
3036 default:
3037 {
3038 if ( _cnt250>=1 ) { break _loop250; } else {throw new NoViableAltException(_t);}
3039 }
3040 }
3041 _cnt250++;
3042 } while (true);
3043 }
3044 break;
3045 }
3046 default:
3047 {
3048 throw new NoViableAltException(_t);
3049 }
3050 }
3051 }
3052 _t = __t237;
3053 _t = _t.getNextSibling();
3054 }
3055 catch (RecognitionException ex) {
3056 if (inputState.guessing==0) {
3057 reportError(ex);
3058 if (_t!=null) {_t = _t.getNextSibling();}
3059 } else {
3060 throw ex;
3061 }
3062 }
3063 _retTree = _t;
3064 }
3065
3066 public final void functionDeclSpecifiers(AST _t) throws RecognitionException {
3067
3068 TNode functionDeclSpecifiers_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
3069
3070 try { // for error handling
3071 {
3072 int _cnt131=0;
3073 _loop131:
3074 do {
3075 if (_t==null) _t=ASTNULL;
3076 switch ( _t.getType()) {
3077 case LITERAL_extern:
3078 case LITERAL_static:
3079 case LITERAL_inline:
3080 {
3082 _t = _retTree;
3083 break;
3084 }
3085 case LITERAL_volatile:
3086 case LITERAL_const:
3087 {
3088 typeQualifier(_t);
3089 _t = _retTree;
3090 break;
3091 }
3092 case LITERAL_struct:
3093 case LITERAL_union:
3094 case LITERAL_enum:
3095 case LITERAL_void:
3096 case LITERAL_char:
3097 case LITERAL_short:
3098 case LITERAL_int:
3099 case LITERAL_long:
3100 case LITERAL_float:
3101 case LITERAL_double:
3102 case LITERAL_signed:
3103 case LITERAL_unsigned:
3104 case 27:
3105 case 28:
3106 case 29:
3107 case 30:
3108 case 31:
3109 case 32:
3110 case LITERAL_wchar_t:
3111 case 34:
3112 case 35:
3113 case 36:
3114 case 37:
3115 case LITERAL_ptrdiff_t:
3116 case LITERAL_intptr_t:
3117 case LITERAL_size_t:
3118 case LITERAL_uintptr_t:
3119 case NTypedefName:
3120 case LITERAL_typeof:
3121 case LITERAL___complex:
3122 {
3123 typeSpecifier(_t);
3124 _t = _retTree;
3125 break;
3126 }
3127 default:
3128 {
3129 if ( _cnt131>=1 ) { break _loop131; } else {throw new NoViableAltException(_t);}
3130 }
3131 }
3132 _cnt131++;
3133 } while (true);
3134 }
3135 }
3136 catch (RecognitionException ex) {
3137 if (inputState.guessing==0) {
3138 reportError(ex);
3139 if (_t!=null) {_t = _t.getNextSibling();}
3140 } else {
3141 throw ex;
3142 }
3143 }
3144 _retTree = _t;
3145 }
3146
3147 public final void compoundStatement(AST _t) throws RecognitionException {
3148
3149 TNode compoundStatement_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
3150
3151 try { // for error handling
3152 AST __t140 = _t;
3153 TNode tmp114_AST_in = (TNode)_t;
3155 _t = _t.getFirstChild();
3156 {
3157 _loop142:
3158 do {
3159 if (_t==null) _t=ASTNULL;
3160 switch ( _t.getType()) {
3161 case NDeclaration:
3162 case LITERAL___label__:
3163 {
3164 declarationList(_t);
3165 _t = _retTree;
3166 break;
3167 }
3168 case NFunctionDef:
3169 {
3170 functionDef(_t);
3171 _t = _retTree;
3172 break;
3173 }
3174 default:
3175 {
3176 break _loop142;
3177 }
3178 }
3179 } while (true);
3180 }
3181 {
3182 if (_t==null) _t=ASTNULL;
3183 switch ( _t.getType()) {
3184 case SEMI:
3185 case LITERAL_while:
3186 case LITERAL_do:
3187 case LITERAL_for:
3188 case LITERAL_goto:
3189 case LITERAL_continue:
3190 case LITERAL_break:
3191 case LITERAL_return:
3192 case LITERAL_case:
3193 case LITERAL_default:
3194 case LITERAL_if:
3195 case LITERAL_switch:
3196 case NStatementExpr:
3197 case NCompoundStatement:
3198 case NLabel:
3199 {
3200 statementList(_t);
3201 _t = _retTree;
3202 break;
3203 }
3204 case RCURLY:
3205 {
3206 break;
3207 }
3208 default:
3209 {
3210 throw new NoViableAltException(_t);
3211 }
3212 }
3213 }
3214 TNode tmp115_AST_in = (TNode)_t;
3215 match(_t,RCURLY);
3216 _t = _t.getNextSibling();
3217 _t = __t140;
3218 _t = _t.getNextSibling();
3219 }
3220 catch (RecognitionException ex) {
3221 if (inputState.guessing==0) {
3222 reportError(ex);
3223 if (_t!=null) {_t = _t.getNextSibling();}
3224 } else {
3225 throw ex;
3226 }
3227 }
3228 _retTree = _t;
3229 }
3230
3231 public final void declarationList(AST _t) throws RecognitionException {
3232
3233 TNode declarationList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
3234
3235 try { // for error handling
3236 {
3237 int _cnt134=0;
3238 _loop134:
3239 do {
3240 if (_t==null) _t=ASTNULL;
3241 if ((_t.getType()==LITERAL___label__)) {
3242 localLabelDecl(_t);
3243 _t = _retTree;
3244 }
3245 else if ((_t.getType()==NDeclaration)) {
3246 declaration(_t);
3247 _t = _retTree;
3248 }
3249 else {
3250 if ( _cnt134>=1 ) { break _loop134; } else {throw new NoViableAltException(_t);}
3251 }
3252
3253 _cnt134++;
3254 } while (true);
3255 }
3256 }
3257 catch (RecognitionException ex) {
3258 if (inputState.guessing==0) {
3259 reportError(ex);
3260 if (_t!=null) {_t = _t.getNextSibling();}
3261 } else {
3262 throw ex;
3263 }
3264 }
3265 _retTree = _t;
3266 }
3267
3268 public final void localLabelDecl(AST _t) throws RecognitionException {
3269
3270 TNode localLabelDecl_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
3271
3272 try { // for error handling
3273 AST __t136 = _t;
3274 TNode tmp116_AST_in = (TNode)_t;
3276 _t = _t.getFirstChild();
3277 {
3278 int _cnt138=0;
3279 _loop138:
3280 do {
3281 if (_t==null) _t=ASTNULL;
3282 if ((_t.getType()==ID)) {
3283 TNode tmp117_AST_in = (TNode)_t;
3284 match(_t,ID);
3285 _t = _t.getNextSibling();
3286 }
3287 else {
3288 if ( _cnt138>=1 ) { break _loop138; } else {throw new NoViableAltException(_t);}
3289 }
3290
3291 _cnt138++;
3292 } while (true);
3293 }
3294 _t = __t136;
3295 _t = _t.getNextSibling();
3296 }
3297 catch (RecognitionException ex) {
3298 if (inputState.guessing==0) {
3299 reportError(ex);
3300 if (_t!=null) {_t = _t.getNextSibling();}
3301 } else {
3302 throw ex;
3303 }
3304 }
3305 _retTree = _t;
3306 }
3307
3308 public final void statementList(AST _t) throws RecognitionException {
3309
3310 TNode statementList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
3311
3312 try { // for error handling
3313 {
3314 int _cnt146=0;
3315 _loop146:
3316 do {
3317 if (_t==null) _t=ASTNULL;
3318 if ((_tokenSet_2.member(_t.getType()))) {
3319 statement(_t);
3320 _t = _retTree;
3321 }
3322 else {
3323 if ( _cnt146>=1 ) { break _loop146; } else {throw new NoViableAltException(_t);}
3324 }
3325
3326 _cnt146++;
3327 } while (true);
3328 }
3329 }
3330 catch (RecognitionException ex) {
3331 if (inputState.guessing==0) {
3332 reportError(ex);
3333 if (_t!=null) {_t = _t.getNextSibling();}
3334 } else {
3335 throw ex;
3336 }
3337 }
3338 _retTree = _t;
3339 }
3340
3341 public final void statement(AST _t) throws RecognitionException {
3342
3343 TNode statement_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
3344
3345 try { // for error handling
3346 statementBody(_t);
3347 _t = _retTree;
3348 }
3349 catch (RecognitionException ex) {
3350 if (inputState.guessing==0) {
3351 reportError(ex);
3352 if (_t!=null) {_t = _t.getNextSibling();}
3353 } else {
3354 throw ex;
3355 }
3356 }
3357 _retTree = _t;
3358 }
3359
3360 public final void statementBody(AST _t) throws RecognitionException {
3361
3362 TNode statementBody_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
3363
3364 try { // for error handling
3365 if (_t==null) _t=ASTNULL;
3366 switch ( _t.getType()) {
3367 case SEMI:
3368 {
3369 TNode tmp118_AST_in = (TNode)_t;
3370 match(_t,SEMI);
3371 _t = _t.getNextSibling();
3372 break;
3373 }
3374 case NCompoundStatement:
3375 {
3377 _t = _retTree;
3378 break;
3379 }
3380 case NStatementExpr:
3381 {
3382 AST __t149 = _t;
3383 TNode tmp119_AST_in = (TNode)_t;
3385 _t = _t.getFirstChild();
3386 expr(_t);
3387 _t = _retTree;
3388 _t = __t149;
3389 _t = _t.getNextSibling();
3390 break;
3391 }
3392 case LITERAL_while:
3393 {
3394 AST __t150 = _t;
3395 TNode tmp120_AST_in = (TNode)_t;
3396 match(_t,LITERAL_while);
3397 _t = _t.getFirstChild();
3398 expr(_t);
3399 _t = _retTree;
3400 statement(_t);
3401 _t = _retTree;
3402 _t = __t150;
3403 _t = _t.getNextSibling();
3404 break;
3405 }
3406 case LITERAL_do:
3407 {
3408 AST __t151 = _t;
3409 TNode tmp121_AST_in = (TNode)_t;
3410 match(_t,LITERAL_do);
3411 _t = _t.getFirstChild();
3412 statement(_t);
3413 _t = _retTree;
3414 expr(_t);
3415 _t = _retTree;
3416 _t = __t151;
3417 _t = _t.getNextSibling();
3418 break;
3419 }
3420 case LITERAL_for:
3421 {
3422 AST __t152 = _t;
3423 TNode tmp122_AST_in = (TNode)_t;
3424 match(_t,LITERAL_for);
3425 _t = _t.getFirstChild();
3426 expr(_t);
3427 _t = _retTree;
3428 expr(_t);
3429 _t = _retTree;
3430 expr(_t);
3431 _t = _retTree;
3432 statement(_t);
3433 _t = _retTree;
3434 _t = __t152;
3435 _t = _t.getNextSibling();
3436 break;
3437 }
3438 case LITERAL_goto:
3439 {
3440 AST __t153 = _t;
3441 TNode tmp123_AST_in = (TNode)_t;
3442 match(_t,LITERAL_goto);
3443 _t = _t.getFirstChild();
3444 expr(_t);
3445 _t = _retTree;
3446 _t = __t153;
3447 _t = _t.getNextSibling();
3448 break;
3449 }
3450 case LITERAL_continue:
3451 {
3452 TNode tmp124_AST_in = (TNode)_t;
3454 _t = _t.getNextSibling();
3455 break;
3456 }
3457 case LITERAL_break:
3458 {
3459 TNode tmp125_AST_in = (TNode)_t;
3460 match(_t,LITERAL_break);
3461 _t = _t.getNextSibling();
3462 break;
3463 }
3464 case LITERAL_return:
3465 {
3466 AST __t154 = _t;
3467 TNode tmp126_AST_in = (TNode)_t;
3469 _t = _t.getFirstChild();
3470 {
3471 if (_t==null) _t=ASTNULL;
3472 switch ( _t.getType()) {
3473 case ID:
3474 case ASSIGN:
3475 case STAR:
3476 case LPAREN:
3477 case DIV_ASSIGN:
3478 case PLUS_ASSIGN:
3479 case MINUS_ASSIGN:
3480 case STAR_ASSIGN:
3481 case MOD_ASSIGN:
3482 case RSHIFT_ASSIGN:
3483 case LSHIFT_ASSIGN:
3484 case BAND_ASSIGN:
3485 case BOR_ASSIGN:
3486 case BXOR_ASSIGN:
3487 case QUESTION:
3488 case LOR:
3489 case LAND:
3490 case BOR:
3491 case BXOR:
3492 case BAND:
3493 case EQUAL:
3494 case NOT_EQUAL:
3495 case LT:
3496 case LTE:
3497 case GT:
3498 case GTE:
3499 case LSHIFT:
3500 case RSHIFT:
3501 case PLUS:
3502 case MINUS:
3503 case DIV:
3504 case MOD:
3505 case INC:
3506 case DEC:
3507 case LITERAL_sizeof:
3508 case CharLiteral:
3509 case NCast:
3510 case NExpressionGroup:
3511 case NInitializer:
3512 case NEmptyExpression:
3513 case NCommaExpr:
3514 case NUnaryExpr:
3515 case NPostfixExpr:
3516 case NRangeExpr:
3517 case NStringSeq:
3518 case NLcurlyInitializer:
3519 case NGnuAsmExpr:
3520 case Number:
3521 case LITERAL___alignof:
3522 {
3523 expr(_t);
3524 _t = _retTree;
3525 break;
3526 }
3527 case 3:
3528 {
3529 break;
3530 }
3531 default:
3532 {
3533 throw new NoViableAltException(_t);
3534 }
3535 }
3536 }
3537 _t = __t154;
3538 _t = _t.getNextSibling();
3539 break;
3540 }
3541 case NLabel:
3542 {
3543 AST __t156 = _t;
3544 TNode tmp127_AST_in = (TNode)_t;
3545 match(_t,NLabel);
3546 _t = _t.getFirstChild();
3547 TNode tmp128_AST_in = (TNode)_t;
3548 match(_t,ID);
3549 _t = _t.getNextSibling();
3550 {
3551 if (_t==null) _t=ASTNULL;
3552 switch ( _t.getType()) {
3553 case SEMI:
3554 case LITERAL_while:
3555 case LITERAL_do:
3556 case LITERAL_for:
3557 case LITERAL_goto:
3558 case LITERAL_continue:
3559 case LITERAL_break:
3560 case LITERAL_return:
3561 case LITERAL_case:
3562 case LITERAL_default:
3563 case LITERAL_if:
3564 case LITERAL_switch:
3565 case NStatementExpr:
3566 case NCompoundStatement:
3567 case NLabel:
3568 {
3569 statement(_t);
3570 _t = _retTree;
3571 break;
3572 }
3573 case 3:
3574 {
3575 break;
3576 }
3577 default:
3578 {
3579 throw new NoViableAltException(_t);
3580 }
3581 }
3582 }
3583 _t = __t156;
3584 _t = _t.getNextSibling();
3585 break;
3586 }
3587 case LITERAL_case:
3588 {
3589 AST __t158 = _t;
3590 TNode tmp129_AST_in = (TNode)_t;
3591 match(_t,LITERAL_case);
3592 _t = _t.getFirstChild();
3593 expr(_t);
3594 _t = _retTree;
3595 {
3596 if (_t==null) _t=ASTNULL;
3597 switch ( _t.getType()) {
3598 case SEMI:
3599 case LITERAL_while:
3600 case LITERAL_do:
3601 case LITERAL_for:
3602 case LITERAL_goto:
3603 case LITERAL_continue:
3604 case LITERAL_break:
3605 case LITERAL_return:
3606 case LITERAL_case:
3607 case LITERAL_default:
3608 case LITERAL_if:
3609 case LITERAL_switch:
3610 case NStatementExpr:
3611 case NCompoundStatement:
3612 case NLabel:
3613 {
3614 statement(_t);
3615 _t = _retTree;
3616 break;
3617 }
3618 case 3:
3619 {
3620 break;
3621 }
3622 default:
3623 {
3624 throw new NoViableAltException(_t);
3625 }
3626 }
3627 }
3628 _t = __t158;
3629 _t = _t.getNextSibling();
3630 break;
3631 }
3632 case LITERAL_default:
3633 {
3634 AST __t160 = _t;
3635 TNode tmp130_AST_in = (TNode)_t;
3637 _t = _t.getFirstChild();
3638 {
3639 if (_t==null) _t=ASTNULL;
3640 switch ( _t.getType()) {
3641 case SEMI:
3642 case LITERAL_while:
3643 case LITERAL_do:
3644 case LITERAL_for:
3645 case LITERAL_goto:
3646 case LITERAL_continue:
3647 case LITERAL_break:
3648 case LITERAL_return:
3649 case LITERAL_case:
3650 case LITERAL_default:
3651 case LITERAL_if:
3652 case LITERAL_switch:
3653 case NStatementExpr:
3654 case NCompoundStatement:
3655 case NLabel:
3656 {
3657 statement(_t);
3658 _t = _retTree;
3659 break;
3660 }
3661 case 3:
3662 {
3663 break;
3664 }
3665 default:
3666 {
3667 throw new NoViableAltException(_t);
3668 }
3669 }
3670 }
3671 _t = __t160;
3672 _t = _t.getNextSibling();
3673 break;
3674 }
3675 case LITERAL_if:
3676 {
3677 AST __t162 = _t;
3678 TNode tmp131_AST_in = (TNode)_t;
3679 match(_t,LITERAL_if);
3680 _t = _t.getFirstChild();
3681 expr(_t);
3682 _t = _retTree;
3683 statement(_t);
3684 _t = _retTree;
3685 {
3686 if (_t==null) _t=ASTNULL;
3687 switch ( _t.getType()) {
3688 case LITERAL_else:
3689 {
3690 TNode tmp132_AST_in = (TNode)_t;
3691 match(_t,LITERAL_else);
3692 _t = _t.getNextSibling();
3693 statement(_t);
3694 _t = _retTree;
3695 break;
3696 }
3697 case 3:
3698 {
3699 break;
3700 }
3701 default:
3702 {
3703 throw new NoViableAltException(_t);
3704 }
3705 }
3706 }
3707 _t = __t162;
3708 _t = _t.getNextSibling();
3709 break;
3710 }
3711 case LITERAL_switch:
3712 {
3713 AST __t164 = _t;
3714 TNode tmp133_AST_in = (TNode)_t;
3716 _t = _t.getFirstChild();
3717 expr(_t);
3718 _t = _retTree;
3719 statement(_t);
3720 _t = _retTree;
3721 _t = __t164;
3722 _t = _t.getNextSibling();
3723 break;
3724 }
3725 default:
3726 {
3727 throw new NoViableAltException(_t);
3728 }
3729 }
3730 }
3731 catch (RecognitionException ex) {
3732 if (inputState.guessing==0) {
3733 reportError(ex);
3734 if (_t!=null) {_t = _t.getNextSibling();}
3735 } else {
3736 throw ex;
3737 }
3738 }
3739 _retTree = _t;
3740 }
3741
3742 public final void assignExpr(AST _t) throws RecognitionException {
3743
3744 TNode assignExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
3745
3746 try { // for error handling
3747 if (_t==null) _t=ASTNULL;
3748 switch ( _t.getType()) {
3749 case ASSIGN:
3750 {
3751 AST __t190 = _t;
3752 TNode tmp134_AST_in = (TNode)_t;
3753 match(_t,ASSIGN);
3754 _t = _t.getFirstChild();
3755 expr(_t);
3756 _t = _retTree;
3757 expr(_t);
3758 _t = _retTree;
3759 _t = __t190;
3760 _t = _t.getNextSibling();
3761 break;
3762 }
3763 case DIV_ASSIGN:
3764 {
3765 AST __t191 = _t;
3766 TNode tmp135_AST_in = (TNode)_t;
3767 match(_t,DIV_ASSIGN);
3768 _t = _t.getFirstChild();
3769 expr(_t);
3770 _t = _retTree;
3771 expr(_t);
3772 _t = _retTree;
3773 _t = __t191;
3774 _t = _t.getNextSibling();
3775 break;
3776 }
3777 case PLUS_ASSIGN:
3778 {
3779 AST __t192 = _t;
3780 TNode tmp136_AST_in = (TNode)_t;
3781 match(_t,PLUS_ASSIGN);
3782 _t = _t.getFirstChild();
3783 expr(_t);
3784 _t = _retTree;
3785 expr(_t);
3786 _t = _retTree;
3787 _t = __t192;
3788 _t = _t.getNextSibling();
3789 break;
3790 }
3791 case MINUS_ASSIGN:
3792 {
3793 AST __t193 = _t;
3794 TNode tmp137_AST_in = (TNode)_t;
3795 match(_t,MINUS_ASSIGN);
3796 _t = _t.getFirstChild();
3797 expr(_t);
3798 _t = _retTree;
3799 expr(_t);
3800 _t = _retTree;
3801 _t = __t193;
3802 _t = _t.getNextSibling();
3803 break;
3804 }
3805 case STAR_ASSIGN:
3806 {
3807 AST __t194 = _t;
3808 TNode tmp138_AST_in = (TNode)_t;
3809 match(_t,STAR_ASSIGN);
3810 _t = _t.getFirstChild();
3811 expr(_t);
3812 _t = _retTree;
3813 expr(_t);
3814 _t = _retTree;
3815 _t = __t194;
3816 _t = _t.getNextSibling();
3817 break;
3818 }
3819 case MOD_ASSIGN:
3820 {
3821 AST __t195 = _t;
3822 TNode tmp139_AST_in = (TNode)_t;
3823 match(_t,MOD_ASSIGN);
3824 _t = _t.getFirstChild();
3825 expr(_t);
3826 _t = _retTree;
3827 expr(_t);
3828 _t = _retTree;
3829 _t = __t195;
3830 _t = _t.getNextSibling();
3831 break;
3832 }
3833 case RSHIFT_ASSIGN:
3834 {
3835 AST __t196 = _t;
3836 TNode tmp140_AST_in = (TNode)_t;
3837 match(_t,RSHIFT_ASSIGN);
3838 _t = _t.getFirstChild();
3839 expr(_t);
3840 _t = _retTree;
3841 expr(_t);
3842 _t = _retTree;
3843 _t = __t196;
3844 _t = _t.getNextSibling();
3845 break;
3846 }
3847 case LSHIFT_ASSIGN:
3848 {
3849 AST __t197 = _t;
3850 TNode tmp141_AST_in = (TNode)_t;
3851 match(_t,LSHIFT_ASSIGN);
3852 _t = _t.getFirstChild();
3853 expr(_t);
3854 _t = _retTree;
3855 expr(_t);
3856 _t = _retTree;
3857 _t = __t197;
3858 _t = _t.getNextSibling();
3859 break;
3860 }
3861 case BAND_ASSIGN:
3862 {
3863 AST __t198 = _t;
3864 TNode tmp142_AST_in = (TNode)_t;
3865 match(_t,BAND_ASSIGN);
3866 _t = _t.getFirstChild();
3867 expr(_t);
3868 _t = _retTree;
3869 expr(_t);
3870 _t = _retTree;
3871 _t = __t198;
3872 _t = _t.getNextSibling();
3873 break;
3874 }
3875 case BOR_ASSIGN:
3876 {
3877 AST __t199 = _t;
3878 TNode tmp143_AST_in = (TNode)_t;
3879 match(_t,BOR_ASSIGN);
3880 _t = _t.getFirstChild();
3881 expr(_t);
3882 _t = _retTree;
3883 expr(_t);
3884 _t = _retTree;
3885 _t = __t199;
3886 _t = _t.getNextSibling();
3887 break;
3888 }
3889 case BXOR_ASSIGN:
3890 {
3891 AST __t200 = _t;
3892 TNode tmp144_AST_in = (TNode)_t;
3893 match(_t,BXOR_ASSIGN);
3894 _t = _t.getFirstChild();
3895 expr(_t);
3896 _t = _retTree;
3897 expr(_t);
3898 _t = _retTree;
3899 _t = __t200;
3900 _t = _t.getNextSibling();
3901 break;
3902 }
3903 default:
3904 {
3905 throw new NoViableAltException(_t);
3906 }
3907 }
3908 }
3909 catch (RecognitionException ex) {
3910 if (inputState.guessing==0) {
3911 reportError(ex);
3912 if (_t!=null) {_t = _t.getNextSibling();}
3913 } else {
3914 throw ex;
3915 }
3916 }
3917 _retTree = _t;
3918 }
3919
3920 public final void conditionalExpr(AST _t) throws RecognitionException {
3921
3922 TNode conditionalExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
3923
3924 try { // for error handling
3925 AST __t202 = _t;
3926 TNode tmp145_AST_in = (TNode)_t;
3927 match(_t,QUESTION);
3928 _t = _t.getFirstChild();
3929 expr(_t);
3930 _t = _retTree;
3931 {
3932 if (_t==null) _t=ASTNULL;
3933 switch ( _t.getType()) {
3934 case ID:
3935 case ASSIGN:
3936 case STAR:
3937 case LPAREN:
3938 case DIV_ASSIGN:
3939 case PLUS_ASSIGN:
3940 case MINUS_ASSIGN:
3941 case STAR_ASSIGN:
3942 case MOD_ASSIGN:
3943 case RSHIFT_ASSIGN:
3944 case LSHIFT_ASSIGN:
3945 case BAND_ASSIGN:
3946 case BOR_ASSIGN:
3947 case BXOR_ASSIGN:
3948 case QUESTION:
3949 case LOR:
3950 case LAND:
3951 case BOR:
3952 case BXOR:
3953 case BAND:
3954 case EQUAL:
3955 case NOT_EQUAL:
3956 case LT:
3957 case LTE:
3958 case GT:
3959 case GTE:
3960 case LSHIFT:
3961 case RSHIFT:
3962 case PLUS:
3963 case MINUS:
3964 case DIV:
3965 case MOD:
3966 case INC:
3967 case DEC:
3968 case LITERAL_sizeof:
3969 case CharLiteral:
3970 case NCast:
3971 case NExpressionGroup:
3972 case NInitializer:
3973 case NEmptyExpression:
3974 case NCommaExpr:
3975 case NUnaryExpr:
3976 case NPostfixExpr:
3977 case NRangeExpr:
3978 case NStringSeq:
3979 case NLcurlyInitializer:
3980 case NGnuAsmExpr:
3981 case Number:
3982 case LITERAL___alignof:
3983 {
3984 expr(_t);
3985 _t = _retTree;
3986 break;
3987 }
3988 case COLON:
3989 {
3990 break;
3991 }
3992 default:
3993 {
3994 throw new NoViableAltException(_t);
3995 }
3996 }
3997 }
3998 TNode tmp146_AST_in = (TNode)_t;
3999 match(_t,COLON);
4000 _t = _t.getNextSibling();
4001 expr(_t);
4002 _t = _retTree;
4003 _t = __t202;
4004 _t = _t.getNextSibling();
4005 }
4006 catch (RecognitionException ex) {
4007 if (inputState.guessing==0) {
4008 reportError(ex);
4009 if (_t!=null) {_t = _t.getNextSibling();}
4010 } else {
4011 throw ex;
4012 }
4013 }
4014 _retTree = _t;
4015 }
4016
4017 public final void logicalOrExpr(AST _t) throws RecognitionException {
4018
4019 TNode logicalOrExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4020
4021 try { // for error handling
4022 AST __t205 = _t;
4023 TNode tmp147_AST_in = (TNode)_t;
4024 match(_t,LOR);
4025 _t = _t.getFirstChild();
4026 expr(_t);
4027 _t = _retTree;
4028 expr(_t);
4029 _t = _retTree;
4030 _t = __t205;
4031 _t = _t.getNextSibling();
4032 }
4033 catch (RecognitionException ex) {
4034 if (inputState.guessing==0) {
4035 reportError(ex);
4036 if (_t!=null) {_t = _t.getNextSibling();}
4037 } else {
4038 throw ex;
4039 }
4040 }
4041 _retTree = _t;
4042 }
4043
4044 public final void logicalAndExpr(AST _t) throws RecognitionException {
4045
4046 TNode logicalAndExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4047
4048 try { // for error handling
4049 AST __t207 = _t;
4050 TNode tmp148_AST_in = (TNode)_t;
4051 match(_t,LAND);
4052 _t = _t.getFirstChild();
4053 expr(_t);
4054 _t = _retTree;
4055 expr(_t);
4056 _t = _retTree;
4057 _t = __t207;
4058 _t = _t.getNextSibling();
4059 }
4060 catch (RecognitionException ex) {
4061 if (inputState.guessing==0) {
4062 reportError(ex);
4063 if (_t!=null) {_t = _t.getNextSibling();}
4064 } else {
4065 throw ex;
4066 }
4067 }
4068 _retTree = _t;
4069 }
4070
4071 public final void inclusiveOrExpr(AST _t) throws RecognitionException {
4072
4073 TNode inclusiveOrExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4074
4075 try { // for error handling
4076 AST __t209 = _t;
4077 TNode tmp149_AST_in = (TNode)_t;
4078 match(_t,BOR);
4079 _t = _t.getFirstChild();
4080 expr(_t);
4081 _t = _retTree;
4082 expr(_t);
4083 _t = _retTree;
4084 _t = __t209;
4085 _t = _t.getNextSibling();
4086 }
4087 catch (RecognitionException ex) {
4088 if (inputState.guessing==0) {
4089 reportError(ex);
4090 if (_t!=null) {_t = _t.getNextSibling();}
4091 } else {
4092 throw ex;
4093 }
4094 }
4095 _retTree = _t;
4096 }
4097
4098 public final void exclusiveOrExpr(AST _t) throws RecognitionException {
4099
4100 TNode exclusiveOrExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4101
4102 try { // for error handling
4103 AST __t211 = _t;
4104 TNode tmp150_AST_in = (TNode)_t;
4105 match(_t,BXOR);
4106 _t = _t.getFirstChild();
4107 expr(_t);
4108 _t = _retTree;
4109 expr(_t);
4110 _t = _retTree;
4111 _t = __t211;
4112 _t = _t.getNextSibling();
4113 }
4114 catch (RecognitionException ex) {
4115 if (inputState.guessing==0) {
4116 reportError(ex);
4117 if (_t!=null) {_t = _t.getNextSibling();}
4118 } else {
4119 throw ex;
4120 }
4121 }
4122 _retTree = _t;
4123 }
4124
4125 public final void bitAndExpr(AST _t) throws RecognitionException {
4126
4127 TNode bitAndExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4128
4129 try { // for error handling
4130 AST __t213 = _t;
4131 TNode tmp151_AST_in = (TNode)_t;
4132 match(_t,BAND);
4133 _t = _t.getFirstChild();
4134 expr(_t);
4135 _t = _retTree;
4136 expr(_t);
4137 _t = _retTree;
4138 _t = __t213;
4139 _t = _t.getNextSibling();
4140 }
4141 catch (RecognitionException ex) {
4142 if (inputState.guessing==0) {
4143 reportError(ex);
4144 if (_t!=null) {_t = _t.getNextSibling();}
4145 } else {
4146 throw ex;
4147 }
4148 }
4149 _retTree = _t;
4150 }
4151
4152 public final void equalityExpr(AST _t) throws RecognitionException {
4153
4154 TNode equalityExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4155
4156 try { // for error handling
4157 if (_t==null) _t=ASTNULL;
4158 switch ( _t.getType()) {
4159 case EQUAL:
4160 {
4161 AST __t215 = _t;
4162 TNode tmp152_AST_in = (TNode)_t;
4163 match(_t,EQUAL);
4164 _t = _t.getFirstChild();
4165 expr(_t);
4166 _t = _retTree;
4167 expr(_t);
4168 _t = _retTree;
4169 _t = __t215;
4170 _t = _t.getNextSibling();
4171 break;
4172 }
4173 case NOT_EQUAL:
4174 {
4175 AST __t216 = _t;
4176 TNode tmp153_AST_in = (TNode)_t;
4177 match(_t,NOT_EQUAL);
4178 _t = _t.getFirstChild();
4179 expr(_t);
4180 _t = _retTree;
4181 expr(_t);
4182 _t = _retTree;
4183 _t = __t216;
4184 _t = _t.getNextSibling();
4185 break;
4186 }
4187 default:
4188 {
4189 throw new NoViableAltException(_t);
4190 }
4191 }
4192 }
4193 catch (RecognitionException ex) {
4194 if (inputState.guessing==0) {
4195 reportError(ex);
4196 if (_t!=null) {_t = _t.getNextSibling();}
4197 } else {
4198 throw ex;
4199 }
4200 }
4201 _retTree = _t;
4202 }
4203
4204 public final void relationalExpr(AST _t) throws RecognitionException {
4205
4206 TNode relationalExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4207
4208 try { // for error handling
4209 if (_t==null) _t=ASTNULL;
4210 switch ( _t.getType()) {
4211 case LT:
4212 {
4213 AST __t218 = _t;
4214 TNode tmp154_AST_in = (TNode)_t;
4215 match(_t,LT);
4216 _t = _t.getFirstChild();
4217 expr(_t);
4218 _t = _retTree;
4219 expr(_t);
4220 _t = _retTree;
4221 _t = __t218;
4222 _t = _t.getNextSibling();
4223 break;
4224 }
4225 case LTE:
4226 {
4227 AST __t219 = _t;
4228 TNode tmp155_AST_in = (TNode)_t;
4229 match(_t,LTE);
4230 _t = _t.getFirstChild();
4231 expr(_t);
4232 _t = _retTree;
4233 expr(_t);
4234 _t = _retTree;
4235 _t = __t219;
4236 _t = _t.getNextSibling();
4237 break;
4238 }
4239 case GT:
4240 {
4241 AST __t220 = _t;
4242 TNode tmp156_AST_in = (TNode)_t;
4243 match(_t,GT);
4244 _t = _t.getFirstChild();
4245 expr(_t);
4246 _t = _retTree;
4247 expr(_t);
4248 _t = _retTree;
4249 _t = __t220;
4250 _t = _t.getNextSibling();
4251 break;
4252 }
4253 case GTE:
4254 {
4255 AST __t221 = _t;
4256 TNode tmp157_AST_in = (TNode)_t;
4257 match(_t,GTE);
4258 _t = _t.getFirstChild();
4259 expr(_t);
4260 _t = _retTree;
4261 expr(_t);
4262 _t = _retTree;
4263 _t = __t221;
4264 _t = _t.getNextSibling();
4265 break;
4266 }
4267 default:
4268 {
4269 throw new NoViableAltException(_t);
4270 }
4271 }
4272 }
4273 catch (RecognitionException ex) {
4274 if (inputState.guessing==0) {
4275 reportError(ex);
4276 if (_t!=null) {_t = _t.getNextSibling();}
4277 } else {
4278 throw ex;
4279 }
4280 }
4281 _retTree = _t;
4282 }
4283
4284 public final void shiftExpr(AST _t) throws RecognitionException {
4285
4286 TNode shiftExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4287
4288 try { // for error handling
4289 if (_t==null) _t=ASTNULL;
4290 switch ( _t.getType()) {
4291 case LSHIFT:
4292 {
4293 AST __t223 = _t;
4294 TNode tmp158_AST_in = (TNode)_t;
4295 match(_t,LSHIFT);
4296 _t = _t.getFirstChild();
4297 expr(_t);
4298 _t = _retTree;
4299 expr(_t);
4300 _t = _retTree;
4301 _t = __t223;
4302 _t = _t.getNextSibling();
4303 break;
4304 }
4305 case RSHIFT:
4306 {
4307 AST __t224 = _t;
4308 TNode tmp159_AST_in = (TNode)_t;
4309 match(_t,RSHIFT);
4310 _t = _t.getFirstChild();
4311 expr(_t);
4312 _t = _retTree;
4313 expr(_t);
4314 _t = _retTree;
4315 _t = __t224;
4316 _t = _t.getNextSibling();
4317 break;
4318 }
4319 default:
4320 {
4321 throw new NoViableAltException(_t);
4322 }
4323 }
4324 }
4325 catch (RecognitionException ex) {
4326 if (inputState.guessing==0) {
4327 reportError(ex);
4328 if (_t!=null) {_t = _t.getNextSibling();}
4329 } else {
4330 throw ex;
4331 }
4332 }
4333 _retTree = _t;
4334 }
4335
4336 public final void additiveExpr(AST _t) throws RecognitionException {
4337
4338 TNode additiveExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4339
4340 try { // for error handling
4341 if (_t==null) _t=ASTNULL;
4342 switch ( _t.getType()) {
4343 case PLUS:
4344 {
4345 AST __t226 = _t;
4346 TNode tmp160_AST_in = (TNode)_t;
4347 match(_t,PLUS);
4348 _t = _t.getFirstChild();
4349 expr(_t);
4350 _t = _retTree;
4351 expr(_t);
4352 _t = _retTree;
4353 _t = __t226;
4354 _t = _t.getNextSibling();
4355 break;
4356 }
4357 case MINUS:
4358 {
4359 AST __t227 = _t;
4360 TNode tmp161_AST_in = (TNode)_t;
4361 match(_t,MINUS);
4362 _t = _t.getFirstChild();
4363 expr(_t);
4364 _t = _retTree;
4365 expr(_t);
4366 _t = _retTree;
4367 _t = __t227;
4368 _t = _t.getNextSibling();
4369 break;
4370 }
4371 default:
4372 {
4373 throw new NoViableAltException(_t);
4374 }
4375 }
4376 }
4377 catch (RecognitionException ex) {
4378 if (inputState.guessing==0) {
4379 reportError(ex);
4380 if (_t!=null) {_t = _t.getNextSibling();}
4381 } else {
4382 throw ex;
4383 }
4384 }
4385 _retTree = _t;
4386 }
4387
4388 public final void multExpr(AST _t) throws RecognitionException {
4389
4390 TNode multExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4391
4392 try { // for error handling
4393 if (_t==null) _t=ASTNULL;
4394 switch ( _t.getType()) {
4395 case STAR:
4396 {
4397 AST __t229 = _t;
4398 TNode tmp162_AST_in = (TNode)_t;
4399 match(_t,STAR);
4400 _t = _t.getFirstChild();
4401 expr(_t);
4402 _t = _retTree;
4403 expr(_t);
4404 _t = _retTree;
4405 _t = __t229;
4406 _t = _t.getNextSibling();
4407 break;
4408 }
4409 case DIV:
4410 {
4411 AST __t230 = _t;
4412 TNode tmp163_AST_in = (TNode)_t;
4413 match(_t,DIV);
4414 _t = _t.getFirstChild();
4415 expr(_t);
4416 _t = _retTree;
4417 expr(_t);
4418 _t = _retTree;
4419 _t = __t230;
4420 _t = _t.getNextSibling();
4421 break;
4422 }
4423 case MOD:
4424 {
4425 AST __t231 = _t;
4426 TNode tmp164_AST_in = (TNode)_t;
4427 match(_t,MOD);
4428 _t = _t.getFirstChild();
4429 expr(_t);
4430 _t = _retTree;
4431 expr(_t);
4432 _t = _retTree;
4433 _t = __t231;
4434 _t = _t.getNextSibling();
4435 break;
4436 }
4437 default:
4438 {
4439 throw new NoViableAltException(_t);
4440 }
4441 }
4442 }
4443 catch (RecognitionException ex) {
4444 if (inputState.guessing==0) {
4445 reportError(ex);
4446 if (_t!=null) {_t = _t.getNextSibling();}
4447 } else {
4448 throw ex;
4449 }
4450 }
4451 _retTree = _t;
4452 }
4453
4454 public final void castExpr(AST _t) throws RecognitionException {
4455
4456 TNode castExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4457
4458 try { // for error handling
4459 AST __t233 = _t;
4460 TNode tmp165_AST_in = (TNode)_t;
4461 match(_t,NCast);
4462 _t = _t.getFirstChild();
4463 typeName(_t);
4464 _t = _retTree;
4465 TNode tmp166_AST_in = (TNode)_t;
4466 match(_t,RPAREN);
4467 _t = _t.getNextSibling();
4468 expr(_t);
4469 _t = _retTree;
4470 _t = __t233;
4471 _t = _t.getNextSibling();
4472 }
4473 catch (RecognitionException ex) {
4474 if (inputState.guessing==0) {
4475 reportError(ex);
4476 if (_t!=null) {_t = _t.getNextSibling();}
4477 } else {
4478 throw ex;
4479 }
4480 }
4481 _retTree = _t;
4482 }
4483
4484 public final void unaryExpr(AST _t) throws RecognitionException {
4485
4486 TNode unaryExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4487
4488 try { // for error handling
4489 if (_t==null) _t=ASTNULL;
4490 switch ( _t.getType()) {
4491 case INC:
4492 {
4493 AST __t252 = _t;
4494 TNode tmp167_AST_in = (TNode)_t;
4495 match(_t,INC);
4496 _t = _t.getFirstChild();
4497 expr(_t);
4498 _t = _retTree;
4499 _t = __t252;
4500 _t = _t.getNextSibling();
4501 break;
4502 }
4503 case DEC:
4504 {
4505 AST __t253 = _t;
4506 TNode tmp168_AST_in = (TNode)_t;
4507 match(_t,DEC);
4508 _t = _t.getFirstChild();
4509 expr(_t);
4510 _t = _retTree;
4511 _t = __t253;
4512 _t = _t.getNextSibling();
4513 break;
4514 }
4515 case NUnaryExpr:
4516 {
4517 AST __t254 = _t;
4518 TNode tmp169_AST_in = (TNode)_t;
4519 match(_t,NUnaryExpr);
4520 _t = _t.getFirstChild();
4521 unaryOperator(_t);
4522 _t = _retTree;
4523 expr(_t);
4524 _t = _retTree;
4525 _t = __t254;
4526 _t = _t.getNextSibling();
4527 break;
4528 }
4529 case LITERAL_sizeof:
4530 {
4531 AST __t255 = _t;
4532 TNode tmp170_AST_in = (TNode)_t;
4534 _t = _t.getFirstChild();
4535 {
4536 boolean synPredMatched258 = false;
4537 if (_t==null) _t=ASTNULL;
4538 if (((_t.getType()==LPAREN))) {
4539 AST __t258 = _t;
4540 synPredMatched258 = true;
4541 inputState.guessing++;
4542 try {
4543 {
4544 TNode tmp171_AST_in = (TNode)_t;
4545 match(_t,LPAREN);
4546 _t = _t.getNextSibling();
4547 typeName(_t);
4548 _t = _retTree;
4549 }
4550 }
4551 catch (RecognitionException pe) {
4552 synPredMatched258 = false;
4553 }
4554 _t = __t258;
4555inputState.guessing--;
4556 }
4557 if ( synPredMatched258 ) {
4558 TNode tmp172_AST_in = (TNode)_t;
4559 match(_t,LPAREN);
4560 _t = _t.getNextSibling();
4561 typeName(_t);
4562 _t = _retTree;
4563 TNode tmp173_AST_in = (TNode)_t;
4564 match(_t,RPAREN);
4565 _t = _t.getNextSibling();
4566 }
4567 else if ((_tokenSet_3.member(_t.getType()))) {
4568 expr(_t);
4569 _t = _retTree;
4570 }
4571 else {
4572 throw new NoViableAltException(_t);
4573 }
4574
4575 }
4576 _t = __t255;
4577 _t = _t.getNextSibling();
4578 break;
4579 }
4580 case LITERAL___alignof:
4581 {
4582 AST __t259 = _t;
4583 TNode tmp174_AST_in = (TNode)_t;
4585 _t = _t.getFirstChild();
4586 {
4587 boolean synPredMatched262 = false;
4588 if (_t==null) _t=ASTNULL;
4589 if (((_t.getType()==LPAREN))) {
4590 AST __t262 = _t;
4591 synPredMatched262 = true;
4592 inputState.guessing++;
4593 try {
4594 {
4595 TNode tmp175_AST_in = (TNode)_t;
4596 match(_t,LPAREN);
4597 _t = _t.getNextSibling();
4598 typeName(_t);
4599 _t = _retTree;
4600 }
4601 }
4602 catch (RecognitionException pe) {
4603 synPredMatched262 = false;
4604 }
4605 _t = __t262;
4606inputState.guessing--;
4607 }
4608 if ( synPredMatched262 ) {
4609 TNode tmp176_AST_in = (TNode)_t;
4610 match(_t,LPAREN);
4611 _t = _t.getNextSibling();
4612 typeName(_t);
4613 _t = _retTree;
4614 TNode tmp177_AST_in = (TNode)_t;
4615 match(_t,RPAREN);
4616 _t = _t.getNextSibling();
4617 }
4618 else if ((_tokenSet_3.member(_t.getType()))) {
4619 expr(_t);
4620 _t = _retTree;
4621 }
4622 else {
4623 throw new NoViableAltException(_t);
4624 }
4625
4626 }
4627 _t = __t259;
4628 _t = _t.getNextSibling();
4629 break;
4630 }
4631 default:
4632 {
4633 throw new NoViableAltException(_t);
4634 }
4635 }
4636 }
4637 catch (RecognitionException ex) {
4638 if (inputState.guessing==0) {
4639 reportError(ex);
4640 if (_t!=null) {_t = _t.getNextSibling();}
4641 } else {
4642 throw ex;
4643 }
4644 }
4645 _retTree = _t;
4646 }
4647
4648 public final void postfixExpr(AST _t) throws RecognitionException {
4649
4650 TNode postfixExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4651
4652 try { // for error handling
4653 AST __t265 = _t;
4654 TNode tmp178_AST_in = (TNode)_t;
4655 match(_t,NPostfixExpr);
4656 _t = _t.getFirstChild();
4657 primaryExpr(_t);
4658 _t = _retTree;
4659 {
4660 int _cnt269=0;
4661 _loop269:
4662 do {
4663 if (_t==null) _t=ASTNULL;
4664 switch ( _t.getType()) {
4665 case PTR:
4666 {
4667 TNode tmp179_AST_in = (TNode)_t;
4668 match(_t,PTR);
4669 _t = _t.getNextSibling();
4670 TNode tmp180_AST_in = (TNode)_t;
4671 match(_t,ID);
4672 _t = _t.getNextSibling();
4673 break;
4674 }
4675 case DOT:
4676 {
4677 TNode tmp181_AST_in = (TNode)_t;
4678 match(_t,DOT);
4679 _t = _t.getNextSibling();
4680 TNode tmp182_AST_in = (TNode)_t;
4681 match(_t,ID);
4682 _t = _t.getNextSibling();
4683 break;
4684 }
4685 case NFunctionCallArgs:
4686 {
4687 AST __t267 = _t;
4688 TNode tmp183_AST_in = (TNode)_t;
4690 _t = _t.getFirstChild();
4691 {
4692 if (_t==null) _t=ASTNULL;
4693 switch ( _t.getType()) {
4694 case ID:
4695 case ASSIGN:
4696 case STAR:
4697 case LPAREN:
4698 case DIV_ASSIGN:
4699 case PLUS_ASSIGN:
4700 case MINUS_ASSIGN:
4701 case STAR_ASSIGN:
4702 case MOD_ASSIGN:
4703 case RSHIFT_ASSIGN:
4704 case LSHIFT_ASSIGN:
4705 case BAND_ASSIGN:
4706 case BOR_ASSIGN:
4707 case BXOR_ASSIGN:
4708 case QUESTION:
4709 case LOR:
4710 case LAND:
4711 case BOR:
4712 case BXOR:
4713 case BAND:
4714 case EQUAL:
4715 case NOT_EQUAL:
4716 case LT:
4717 case LTE:
4718 case GT:
4719 case GTE:
4720 case LSHIFT:
4721 case RSHIFT:
4722 case PLUS:
4723 case MINUS:
4724 case DIV:
4725 case MOD:
4726 case INC:
4727 case DEC:
4728 case LITERAL_sizeof:
4729 case CharLiteral:
4730 case NCast:
4731 case NExpressionGroup:
4732 case NInitializer:
4733 case NEmptyExpression:
4734 case NCommaExpr:
4735 case NUnaryExpr:
4736 case NPostfixExpr:
4737 case NRangeExpr:
4738 case NStringSeq:
4739 case NLcurlyInitializer:
4740 case NGnuAsmExpr:
4741 case Number:
4742 case LITERAL___alignof:
4743 {
4744 argExprList(_t);
4745 _t = _retTree;
4746 break;
4747 }
4748 case RPAREN:
4749 {
4750 break;
4751 }
4752 default:
4753 {
4754 throw new NoViableAltException(_t);
4755 }
4756 }
4757 }
4758 TNode tmp184_AST_in = (TNode)_t;
4759 match(_t,RPAREN);
4760 _t = _t.getNextSibling();
4761 _t = __t267;
4762 _t = _t.getNextSibling();
4763 break;
4764 }
4765 case LBRACKET:
4766 {
4767 TNode tmp185_AST_in = (TNode)_t;
4768 match(_t,LBRACKET);
4769 _t = _t.getNextSibling();
4770 expr(_t);
4771 _t = _retTree;
4772 TNode tmp186_AST_in = (TNode)_t;
4773 match(_t,RBRACKET);
4774 _t = _t.getNextSibling();
4775 break;
4776 }
4777 case INC:
4778 {
4779 TNode tmp187_AST_in = (TNode)_t;
4780 match(_t,INC);
4781 _t = _t.getNextSibling();
4782 break;
4783 }
4784 case DEC:
4785 {
4786 TNode tmp188_AST_in = (TNode)_t;
4787 match(_t,DEC);
4788 _t = _t.getNextSibling();
4789 break;
4790 }
4791 default:
4792 {
4793 if ( _cnt269>=1 ) { break _loop269; } else {throw new NoViableAltException(_t);}
4794 }
4795 }
4796 _cnt269++;
4797 } while (true);
4798 }
4799 _t = __t265;
4800 _t = _t.getNextSibling();
4801 }
4802 catch (RecognitionException ex) {
4803 if (inputState.guessing==0) {
4804 reportError(ex);
4805 if (_t!=null) {_t = _t.getNextSibling();}
4806 } else {
4807 throw ex;
4808 }
4809 }
4810 _retTree = _t;
4811 }
4812
4813 public final void primaryExpr(AST _t) throws RecognitionException {
4814
4815 TNode primaryExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4816
4817 try { // for error handling
4818 if (_t==null) _t=ASTNULL;
4819 switch ( _t.getType()) {
4820 case ID:
4821 {
4822 TNode tmp189_AST_in = (TNode)_t;
4823 match(_t,ID);
4824 _t = _t.getNextSibling();
4825 break;
4826 }
4827 case Number:
4828 {
4829 TNode tmp190_AST_in = (TNode)_t;
4830 match(_t,Number);
4831 _t = _t.getNextSibling();
4832 break;
4833 }
4834 case CharLiteral:
4835 {
4836 charConst(_t);
4837 _t = _retTree;
4838 break;
4839 }
4840 case NStringSeq:
4841 {
4842 stringConst(_t);
4843 _t = _retTree;
4844 break;
4845 }
4846 case NExpressionGroup:
4847 {
4848 AST __t271 = _t;
4849 TNode tmp191_AST_in = (TNode)_t;
4851 _t = _t.getFirstChild();
4852 expr(_t);
4853 _t = _retTree;
4854 _t = __t271;
4855 _t = _t.getNextSibling();
4856 break;
4857 }
4858 default:
4859 {
4860 throw new NoViableAltException(_t);
4861 }
4862 }
4863 }
4864 catch (RecognitionException ex) {
4865 if (inputState.guessing==0) {
4866 reportError(ex);
4867 if (_t!=null) {_t = _t.getNextSibling();}
4868 } else {
4869 throw ex;
4870 }
4871 }
4872 _retTree = _t;
4873 }
4874
4875 public final void commaExpr(AST _t) throws RecognitionException {
4876
4877 TNode commaExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4878
4879 try { // for error handling
4880 AST __t167 = _t;
4881 TNode tmp192_AST_in = (TNode)_t;
4882 match(_t,NCommaExpr);
4883 _t = _t.getFirstChild();
4884 expr(_t);
4885 _t = _retTree;
4886 expr(_t);
4887 _t = _retTree;
4888 _t = __t167;
4889 _t = _t.getNextSibling();
4890 }
4891 catch (RecognitionException ex) {
4892 if (inputState.guessing==0) {
4893 reportError(ex);
4894 if (_t!=null) {_t = _t.getNextSibling();}
4895 } else {
4896 throw ex;
4897 }
4898 }
4899 _retTree = _t;
4900 }
4901
4902 public final void emptyExpr(AST _t) throws RecognitionException {
4903
4904 TNode emptyExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4905
4906 try { // for error handling
4907 TNode tmp193_AST_in = (TNode)_t;
4909 _t = _t.getNextSibling();
4910 }
4911 catch (RecognitionException ex) {
4912 if (inputState.guessing==0) {
4913 reportError(ex);
4914 if (_t!=null) {_t = _t.getNextSibling();}
4915 } else {
4916 throw ex;
4917 }
4918 }
4919 _retTree = _t;
4920 }
4921
4922 public final void compoundStatementExpr(AST _t) throws RecognitionException {
4923
4924 TNode compoundStatementExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4925
4926 try { // for error handling
4927 AST __t170 = _t;
4928 TNode tmp194_AST_in = (TNode)_t;
4929 match(_t,LPAREN);
4930 _t = _t.getFirstChild();
4932 _t = _retTree;
4933 TNode tmp195_AST_in = (TNode)_t;
4934 match(_t,RPAREN);
4935 _t = _t.getNextSibling();
4936 _t = __t170;
4937 _t = _t.getNextSibling();
4938 }
4939 catch (RecognitionException ex) {
4940 if (inputState.guessing==0) {
4941 reportError(ex);
4942 if (_t!=null) {_t = _t.getNextSibling();}
4943 } else {
4944 throw ex;
4945 }
4946 }
4947 _retTree = _t;
4948 }
4949
4950 public final void rangeExpr(AST _t) throws RecognitionException {
4951
4952 TNode rangeExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4953
4954 try { // for error handling
4955 AST __t172 = _t;
4956 TNode tmp196_AST_in = (TNode)_t;
4957 match(_t,NRangeExpr);
4958 _t = _t.getFirstChild();
4959 expr(_t);
4960 _t = _retTree;
4961 TNode tmp197_AST_in = (TNode)_t;
4962 match(_t,VARARGS);
4963 _t = _t.getNextSibling();
4964 expr(_t);
4965 _t = _retTree;
4966 _t = __t172;
4967 _t = _t.getNextSibling();
4968 }
4969 catch (RecognitionException ex) {
4970 if (inputState.guessing==0) {
4971 reportError(ex);
4972 if (_t!=null) {_t = _t.getNextSibling();}
4973 } else {
4974 throw ex;
4975 }
4976 }
4977 _retTree = _t;
4978 }
4979
4980 public final void gnuAsmExpr(AST _t) throws RecognitionException {
4981
4982 TNode gnuAsmExpr_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
4983
4984 try { // for error handling
4985 AST __t174 = _t;
4986 TNode tmp198_AST_in = (TNode)_t;
4987 match(_t,NGnuAsmExpr);
4988 _t = _t.getFirstChild();
4989 {
4990 if (_t==null) _t=ASTNULL;
4991 switch ( _t.getType()) {
4992 case LITERAL_volatile:
4993 {
4994 TNode tmp199_AST_in = (TNode)_t;
4996 _t = _t.getNextSibling();
4997 break;
4998 }
4999 case LPAREN:
5000 {
5001 break;
5002 }
5003 default:
5004 {
5005 throw new NoViableAltException(_t);
5006 }
5007 }
5008 }
5009 TNode tmp200_AST_in = (TNode)_t;
5010 match(_t,LPAREN);
5011 _t = _t.getNextSibling();
5012 stringConst(_t);
5013 _t = _retTree;
5014 {
5015 if (_t==null) _t=ASTNULL;
5016 if ((_t.getType()==COLON)) {
5017 TNode tmp201_AST_in = (TNode)_t;
5018 match(_t,COLON);
5019 _t = _t.getNextSibling();
5020 {
5021 if (_t==null) _t=ASTNULL;
5022 switch ( _t.getType()) {
5023 case NStringSeq:
5024 {
5025 strOptExprPair(_t);
5026 _t = _retTree;
5027 {
5028 _loop179:
5029 do {
5030 if (_t==null) _t=ASTNULL;
5031 if ((_t.getType()==COMMA)) {
5032 TNode tmp202_AST_in = (TNode)_t;
5033 match(_t,COMMA);
5034 _t = _t.getNextSibling();
5035 strOptExprPair(_t);
5036 _t = _retTree;
5037 }
5038 else {
5039 break _loop179;
5040 }
5041
5042 } while (true);
5043 }
5044 break;
5045 }
5046 case COLON:
5047 case RPAREN:
5048 {
5049 break;
5050 }
5051 default:
5052 {
5053 throw new NoViableAltException(_t);
5054 }
5055 }
5056 }
5057 {
5058 if (_t==null) _t=ASTNULL;
5059 if ((_t.getType()==COLON)) {
5060 TNode tmp203_AST_in = (TNode)_t;
5061 match(_t,COLON);
5062 _t = _t.getNextSibling();
5063 {
5064 if (_t==null) _t=ASTNULL;
5065 switch ( _t.getType()) {
5066 case NStringSeq:
5067 {
5068 strOptExprPair(_t);
5069 _t = _retTree;
5070 {
5071 _loop183:
5072 do {
5073 if (_t==null) _t=ASTNULL;
5074 if ((_t.getType()==COMMA)) {
5075 TNode tmp204_AST_in = (TNode)_t;
5076 match(_t,COMMA);
5077 _t = _t.getNextSibling();
5078 strOptExprPair(_t);
5079 _t = _retTree;
5080 }
5081 else {
5082 break _loop183;
5083 }
5084
5085 } while (true);
5086 }
5087 break;
5088 }
5089 case COLON:
5090 case RPAREN:
5091 {
5092 break;
5093 }
5094 default:
5095 {
5096 throw new NoViableAltException(_t);
5097 }
5098 }
5099 }
5100 }
5101 else if ((_t.getType()==COLON||_t.getType()==RPAREN)) {
5102 }
5103 else {
5104 throw new NoViableAltException(_t);
5105 }
5106
5107 }
5108 }
5109 else if ((_t.getType()==COLON||_t.getType()==RPAREN)) {
5110 }
5111 else {
5112 throw new NoViableAltException(_t);
5113 }
5114
5115 }
5116 {
5117 if (_t==null) _t=ASTNULL;
5118 switch ( _t.getType()) {
5119 case COLON:
5120 {
5121 TNode tmp205_AST_in = (TNode)_t;
5122 match(_t,COLON);
5123 _t = _t.getNextSibling();
5124 stringConst(_t);
5125 _t = _retTree;
5126 {
5127 _loop186:
5128 do {
5129 if (_t==null) _t=ASTNULL;
5130 if ((_t.getType()==COMMA)) {
5131 TNode tmp206_AST_in = (TNode)_t;
5132 match(_t,COMMA);
5133 _t = _t.getNextSibling();
5134 stringConst(_t);
5135 _t = _retTree;
5136 }
5137 else {
5138 break _loop186;
5139 }
5140
5141 } while (true);
5142 }
5143 break;
5144 }
5145 case RPAREN:
5146 {
5147 break;
5148 }
5149 default:
5150 {
5151 throw new NoViableAltException(_t);
5152 }
5153 }
5154 }
5155 TNode tmp207_AST_in = (TNode)_t;
5156 match(_t,RPAREN);
5157 _t = _t.getNextSibling();
5158 _t = __t174;
5159 _t = _t.getNextSibling();
5160 }
5161 catch (RecognitionException ex) {
5162 if (inputState.guessing==0) {
5163 reportError(ex);
5164 if (_t!=null) {_t = _t.getNextSibling();}
5165 } else {
5166 throw ex;
5167 }
5168 }
5169 _retTree = _t;
5170 }
5171
5172 protected final void stringConst(AST _t) throws RecognitionException {
5173
5174 TNode stringConst_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
5175
5176 try { // for error handling
5177 AST __t277 = _t;
5178 TNode tmp208_AST_in = (TNode)_t;
5179 match(_t,NStringSeq);
5180 _t = _t.getFirstChild();
5181 {
5182 int _cnt279=0;
5183 _loop279:
5184 do {
5185 if (_t==null) _t=ASTNULL;
5186 if ((_t.getType()==StringLiteral)) {
5187 TNode tmp209_AST_in = (TNode)_t;
5188 match(_t,StringLiteral);
5189 _t = _t.getNextSibling();
5190 }
5191 else {
5192 if ( _cnt279>=1 ) { break _loop279; } else {throw new NoViableAltException(_t);}
5193 }
5194
5195 _cnt279++;
5196 } while (true);
5197 }
5198 _t = __t277;
5199 _t = _t.getNextSibling();
5200 }
5201 catch (RecognitionException ex) {
5202 if (inputState.guessing==0) {
5203 reportError(ex);
5204 if (_t!=null) {_t = _t.getNextSibling();}
5205 } else {
5206 throw ex;
5207 }
5208 }
5209 _retTree = _t;
5210 }
5211
5212 public final void strOptExprPair(AST _t) throws RecognitionException {
5213
5214 TNode strOptExprPair_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
5215
5216 try { // for error handling
5217 stringConst(_t);
5218 _t = _retTree;
5219 {
5220 if (_t==null) _t=ASTNULL;
5221 switch ( _t.getType()) {
5222 case LPAREN:
5223 {
5224 TNode tmp210_AST_in = (TNode)_t;
5225 match(_t,LPAREN);
5226 _t = _t.getNextSibling();
5227 expr(_t);
5228 _t = _retTree;
5229 TNode tmp211_AST_in = (TNode)_t;
5230 match(_t,RPAREN);
5231 _t = _t.getNextSibling();
5232 break;
5233 }
5234 case COMMA:
5235 case COLON:
5236 case RPAREN:
5237 {
5238 break;
5239 }
5240 default:
5241 {
5242 throw new NoViableAltException(_t);
5243 }
5244 }
5245 }
5246 }
5247 catch (RecognitionException ex) {
5248 if (inputState.guessing==0) {
5249 reportError(ex);
5250 if (_t!=null) {_t = _t.getNextSibling();}
5251 } else {
5252 throw ex;
5253 }
5254 }
5255 _retTree = _t;
5256 }
5257
5258 public final void unaryOperator(AST _t) throws RecognitionException {
5259
5260 TNode unaryOperator_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
5261
5262 try { // for error handling
5263 if (_t==null) _t=ASTNULL;
5264 switch ( _t.getType()) {
5265 case BAND:
5266 {
5267 TNode tmp212_AST_in = (TNode)_t;
5268 match(_t,BAND);
5269 _t = _t.getNextSibling();
5270 break;
5271 }
5272 case STAR:
5273 {
5274 TNode tmp213_AST_in = (TNode)_t;
5275 match(_t,STAR);
5276 _t = _t.getNextSibling();
5277 break;
5278 }
5279 case PLUS:
5280 {
5281 TNode tmp214_AST_in = (TNode)_t;
5282 match(_t,PLUS);
5283 _t = _t.getNextSibling();
5284 break;
5285 }
5286 case MINUS:
5287 {
5288 TNode tmp215_AST_in = (TNode)_t;
5289 match(_t,MINUS);
5290 _t = _t.getNextSibling();
5291 break;
5292 }
5293 case BNOT:
5294 {
5295 TNode tmp216_AST_in = (TNode)_t;
5296 match(_t,BNOT);
5297 _t = _t.getNextSibling();
5298 break;
5299 }
5300 case LNOT:
5301 {
5302 TNode tmp217_AST_in = (TNode)_t;
5303 match(_t,LNOT);
5304 _t = _t.getNextSibling();
5305 break;
5306 }
5307 case LAND:
5308 {
5309 TNode tmp218_AST_in = (TNode)_t;
5310 match(_t,LAND);
5311 _t = _t.getNextSibling();
5312 break;
5313 }
5314 case LITERAL___real:
5315 {
5316 TNode tmp219_AST_in = (TNode)_t;
5318 _t = _t.getNextSibling();
5319 break;
5320 }
5321 case LITERAL___imag:
5322 {
5323 TNode tmp220_AST_in = (TNode)_t;
5325 _t = _t.getNextSibling();
5326 break;
5327 }
5328 default:
5329 {
5330 throw new NoViableAltException(_t);
5331 }
5332 }
5333 }
5334 catch (RecognitionException ex) {
5335 if (inputState.guessing==0) {
5336 reportError(ex);
5337 if (_t!=null) {_t = _t.getNextSibling();}
5338 } else {
5339 throw ex;
5340 }
5341 }
5342 _retTree = _t;
5343 }
5344
5345 public final void argExprList(AST _t) throws RecognitionException {
5346
5347 TNode argExprList_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
5348
5349 try { // for error handling
5350 {
5351 int _cnt274=0;
5352 _loop274:
5353 do {
5354 if (_t==null) _t=ASTNULL;
5355 if ((_tokenSet_3.member(_t.getType()))) {
5356 expr(_t);
5357 _t = _retTree;
5358 }
5359 else {
5360 if ( _cnt274>=1 ) { break _loop274; } else {throw new NoViableAltException(_t);}
5361 }
5362
5363 _cnt274++;
5364 } while (true);
5365 }
5366 }
5367 catch (RecognitionException ex) {
5368 if (inputState.guessing==0) {
5369 reportError(ex);
5370 if (_t!=null) {_t = _t.getNextSibling();}
5371 } else {
5372 throw ex;
5373 }
5374 }
5375 _retTree = _t;
5376 }
5377
5378 protected final void charConst(AST _t) throws RecognitionException {
5379
5380 TNode charConst_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
5381
5382 try { // for error handling
5383 TNode tmp221_AST_in = (TNode)_t;
5384 match(_t,CharLiteral);
5385 _t = _t.getNextSibling();
5386 }
5387 catch (RecognitionException ex) {
5388 if (inputState.guessing==0) {
5389 reportError(ex);
5390 if (_t!=null) {_t = _t.getNextSibling();}
5391 } else {
5392 throw ex;
5393 }
5394 }
5395 _retTree = _t;
5396 }
5397
5398 protected final void intConst(AST _t) throws RecognitionException {
5399
5400 TNode intConst_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
5401
5402 try { // for error handling
5403 if (_t==null) _t=ASTNULL;
5404 switch ( _t.getType()) {
5405 case IntOctalConst:
5406 {
5407 TNode tmp222_AST_in = (TNode)_t;
5408 match(_t,IntOctalConst);
5409 _t = _t.getNextSibling();
5410 break;
5411 }
5412 case LongOctalConst:
5413 {
5414 TNode tmp223_AST_in = (TNode)_t;
5416 _t = _t.getNextSibling();
5417 break;
5418 }
5419 case UnsignedOctalConst:
5420 {
5421 TNode tmp224_AST_in = (TNode)_t;
5423 _t = _t.getNextSibling();
5424 break;
5425 }
5426 case IntIntConst:
5427 {
5428 TNode tmp225_AST_in = (TNode)_t;
5429 match(_t,IntIntConst);
5430 _t = _t.getNextSibling();
5431 break;
5432 }
5433 case LongIntConst:
5434 {
5435 TNode tmp226_AST_in = (TNode)_t;
5436 match(_t,LongIntConst);
5437 _t = _t.getNextSibling();
5438 break;
5439 }
5440 case UnsignedIntConst:
5441 {
5442 TNode tmp227_AST_in = (TNode)_t;
5444 _t = _t.getNextSibling();
5445 break;
5446 }
5447 case IntHexConst:
5448 {
5449 TNode tmp228_AST_in = (TNode)_t;
5450 match(_t,IntHexConst);
5451 _t = _t.getNextSibling();
5452 break;
5453 }
5454 case LongHexConst:
5455 {
5456 TNode tmp229_AST_in = (TNode)_t;
5457 match(_t,LongHexConst);
5458 _t = _t.getNextSibling();
5459 break;
5460 }
5461 case UnsignedHexConst:
5462 {
5463 TNode tmp230_AST_in = (TNode)_t;
5465 _t = _t.getNextSibling();
5466 break;
5467 }
5468 default:
5469 {
5470 throw new NoViableAltException(_t);
5471 }
5472 }
5473 }
5474 catch (RecognitionException ex) {
5475 if (inputState.guessing==0) {
5476 reportError(ex);
5477 if (_t!=null) {_t = _t.getNextSibling();}
5478 } else {
5479 throw ex;
5480 }
5481 }
5482 _retTree = _t;
5483 }
5484
5485 protected final void floatConst(AST _t) throws RecognitionException {
5486
5487 TNode floatConst_AST_in = (_t == ASTNULL) ? null : (TNode)_t;
5488
5489 try { // for error handling
5490 if (_t==null) _t=ASTNULL;
5491 switch ( _t.getType()) {
5492 case FloatDoubleConst:
5493 {
5494 TNode tmp231_AST_in = (TNode)_t;
5496 _t = _t.getNextSibling();
5497 break;
5498 }
5499 case DoubleDoubleConst:
5500 {
5501 TNode tmp232_AST_in = (TNode)_t;
5503 _t = _t.getNextSibling();
5504 break;
5505 }
5506 case LongDoubleConst:
5507 {
5508 TNode tmp233_AST_in = (TNode)_t;
5510 _t = _t.getNextSibling();
5511 break;
5512 }
5513 default:
5514 {
5515 throw new NoViableAltException(_t);
5516 }
5517 }
5518 }
5519 catch (RecognitionException ex) {
5520 if (inputState.guessing==0) {
5521 reportError(ex);
5522 if (_t!=null) {_t = _t.getNextSibling();}
5523 } else {
5524 throw ex;
5525 }
5526 }
5527 _retTree = _t;
5528 }
5529
5530
5531 public static final String[] _tokenNames = {
5532 "<0>",
5533 "EOF",
5534 "<2>",
5535 "NULL_TREE_LOOKAHEAD",
5536 "\"typedef\"",
5537 "\"asm\"",
5538 "\"volatile\"",
5539 "LCURLY",
5540 "RCURLY",
5541 "SEMI",
5542 "\"struct\"",
5543 "\"union\"",
5544 "\"enum\"",
5545 "\"auto\"",
5546 "\"register\"",
5547 "\"extern\"",
5548 "\"static\"",
5549 "\"const\"",
5550 "\"void\"",
5551 "\"char\"",
5552 "\"short\"",
5553 "\"int\"",
5554 "\"long\"",
5555 "\"float\"",
5556 "\"double\"",
5557 "\"signed\"",
5558 "\"unsigned\"",
5559 "\"int8_t\"",
5560 "\"uint8_t\"",
5561 "\"int16_t\"",
5562 "\"uint16_t\"",
5563 "\"__int32\"",
5564 "\"int32_t\"",
5565 "\"wchar_t\"",
5566 "\"uint32_t\"",
5567 "\"__int64\"",
5568 "\"int64_t\"",
5569 "\"uint64_t\"",
5570 "\"ptrdiff_t\"",
5571 "\"intptr_t\"",
5572 "\"size_t\"",
5573 "\"uintptr_t\"",
5574 "ID",
5575 "COMMA",
5576 "COLON",
5577 "ASSIGN",
5578 "STAR",
5579 "LPAREN",
5580 "RPAREN",
5581 "LBRACKET",
5582 "RBRACKET",
5583 "VARARGS",
5584 "\"while\"",
5585 "\"do\"",
5586 "\"for\"",
5587 "\"goto\"",
5588 "\"continue\"",
5589 "\"break\"",
5590 "\"return\"",
5591 "\"case\"",
5592 "\"default\"",
5593 "\"if\"",
5594 "\"else\"",
5595 "\"switch\"",
5596 "DIV_ASSIGN",
5597 "PLUS_ASSIGN",
5598 "MINUS_ASSIGN",
5599 "STAR_ASSIGN",
5600 "MOD_ASSIGN",
5601 "RSHIFT_ASSIGN",
5602 "LSHIFT_ASSIGN",
5603 "BAND_ASSIGN",
5604 "BOR_ASSIGN",
5605 "BXOR_ASSIGN",
5606 "QUESTION",
5607 "LOR",
5608 "LAND",
5609 "BOR",
5610 "BXOR",
5611 "BAND",
5612 "EQUAL",
5613 "NOT_EQUAL",
5614 "LT",
5615 "LTE",
5616 "GT",
5617 "GTE",
5618 "LSHIFT",
5619 "RSHIFT",
5620 "PLUS",
5621 "MINUS",
5622 "DIV",
5623 "MOD",
5624 "INC",
5625 "DEC",
5626 "\"sizeof\"",
5627 "BNOT",
5628 "LNOT",
5629 "PTR",
5630 "DOT",
5631 "CharLiteral",
5632 "StringLiteral",
5633 "IntOctalConst",
5634 "LongOctalConst",
5635 "UnsignedOctalConst",
5636 "IntIntConst",
5637 "LongIntConst",
5638 "UnsignedIntConst",
5639 "IntHexConst",
5640 "LongHexConst",
5641 "UnsignedHexConst",
5642 "FloatDoubleConst",
5643 "DoubleDoubleConst",
5644 "LongDoubleConst",
5645 "NTypedefName",
5646 "NInitDecl",
5647 "NDeclarator",
5648 "NStructDeclarator",
5649 "NDeclaration",
5650 "NCast",
5651 "NPointerGroup",
5652 "NExpressionGroup",
5653 "NFunctionCallArgs",
5654 "NNonemptyAbstractDeclarator",
5655 "NInitializer",
5656 "NStatementExpr",
5657 "NEmptyExpression",
5658 "NParameterTypeList",
5659 "NFunctionDef",
5660 "NCompoundStatement",
5661 "NParameterDeclaration",
5662 "NCommaExpr",
5663 "NUnaryExpr",
5664 "NLabel",
5665 "NPostfixExpr",
5666 "NRangeExpr",
5667 "NStringSeq",
5668 "NInitializerElementLabel",
5669 "NLcurlyInitializer",
5670 "NAsmAttribute",
5671 "NGnuAsmExpr",
5672 "NTypeMissing",
5673 "Vocabulary",
5674 "Whitespace",
5675 "Comment",
5676 "CPPComment",
5677 "NonWhitespace",
5678 "a line directive",
5679 "DefineExpr",
5680 "DefineExpr2",
5681 "Space",
5682 "LineDirective",
5683 "BadStringLiteral",
5684 "Escape",
5685 "Digit",
5686 "LongSuffix",
5687 "UnsignedSuffix",
5688 "FloatSuffix",
5689 "Exponent",
5690 "Number",
5691 "\"__label__\"",
5692 "\"inline\"",
5693 "\"typeof\"",
5694 "\"__complex\"",
5695 "\"__attribute\"",
5696 "\"__alignof\"",
5697 "\"__real\"",
5698 "\"__imag\""
5699 };
5700
5701 private static final long[] mk_tokenSet_0() {
5702 long[] data = { 544L, -9214364837600034816L, 4096L, 0L, 0L, 0L};
5703 return data;
5704 }
5705 public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
5706 private static final long[] mk_tokenSet_1() {
5707 long[] data = { 4398046387264L, 562949953421312L, 25769803776L, 0L, 0L, 0L};
5708 return data;
5709 }
5710 public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
5711 private static final long[] mk_tokenSet_2() {
5712 long[] data = { -4616189618054757888L, 1152921504606846976L, 17L, 0L, 0L, 0L};
5713 return data;
5714 }
5715 public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
5716 private static final long[] mk_tokenSet_3() {
5717 long[] data = { 250688651132928L, 2972375790571749375L, 69793221356L, 0L, 0L, 0L};
5718 return data;
5719 }
5720 public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
5721 }
5722
void reportError(NoViableAltException ex)
void reportError(MismatchedTokenException ex)
void reportError(RecognitionException ex)
Class TNode is an implementation of the AST interface and adds many useful features:
Definition: TNode.java:38
static void printTree(final AST t)
print given tree to System.out
Definition: TNode.java:424