3 package com.jogamp.gluegen.cgram;
7 import antlr.CommonAST;
8 import antlr.DumpASTVisitor;
9 import com.jogamp.gluegen.ASTLocusTag;
11import antlr.TokenBuffer;
12import antlr.TokenStreamException;
13import antlr.TokenStreamIOException;
14import antlr.ANTLRException;
15import antlr.LLkParser;
17import antlr.TokenStream;
18import antlr.RecognitionException;
19import antlr.NoViableAltException;
20import antlr.MismatchedTokenException;
21import antlr.SemanticException;
22import antlr.ParserSharedInputState;
23import antlr.collections.impl.BitSet;
24import antlr.collections.AST;
25import java.util.Hashtable;
26import antlr.ASTFactory;
28import antlr.collections.impl.ASTArray;
43 boolean returnValue =
false;
45 for (; node !=
null; node = (
TNode) node.getNextSibling() ) {
74 this.debugging = debug;
80 System.err.println(
"ANTLR Parsing Error: "+ex +
" token name:" + tokenNames[LA(1)]);
81 ex.printStackTrace(System.err);
83 catch (TokenStreamException e) {
84 System.err.println(
"ANTLR Parsing Error: "+ex);
85 ex.printStackTrace(System.err);
89 System.err.println(
"ANTLR Parsing Error from String: " + s);
92 System.err.println(
"ANTLR Parsing Warning from String: " + s);
94 public void match(
int t)
throws MismatchedTokenException {
96 for (
int x=0; x<traceDepth; x++) System.out.print(
" ");
98 System.out.println(
"Match("+tokenNames[t]+
") with LA(1)="+
99 tokenNames[LA(1)] + ((inputState.guessing>0)?
" [inputState.guessing "+ inputState.guessing +
"]":
""));
101 catch (TokenStreamException e) {
102 System.out.println(
"Match("+tokenNames[t]+
") " + ((inputState.guessing>0)?
" [inputState.guessing "+ inputState.guessing +
"]":
""));
110 for (
int x=0; x<traceDepth; x++) System.out.print(
" ");
111 System.out.println(
"token mismatch: "+tokenNames[LA(1)]
112 +
"!="+tokenNames[t]);
114 throw new MismatchedTokenException(tokenNames,
LT(1), t,
false, getFilename());
121 catch (TokenStreamException e) {
127 for (
int x=0; x<traceDepth; x++) System.out.print(
" ");
129 System.out.println(
"> "+rname+
"; LA(1)==("+ tokenNames[
LT(1).getType()]
130 +
") " +
LT(1).getText() +
" [inputState.guessing "+ inputState.guessing +
"]");
132 catch (TokenStreamException e) {
136 for (
int x=0; x<traceDepth; x++) System.out.print(
" ");
138 System.out.println(
"< "+rname+
"; LA(1)==("+ tokenNames[
LT(1).getType()]
139 +
") "+
LT(1).getText() +
" [inputState.guessing "+ inputState.guessing +
"]");
141 catch (TokenStreamException e) {
151 astFactory =
new ASTFactory(getTokenTypeToASTClassMap());
162 astFactory =
new ASTFactory(getTokenTypeToASTClassMap());
173 astFactory =
new ASTFactory(getTokenTypeToASTClassMap());
176 public final void translationUnit() throws RecognitionException, TokenStreamException {
179 ASTPair currentAST =
new ASTPair();
180 TNode translationUnit_AST =
null;
229 astFactory.addASTChild(currentAST, returnAST);
238 throw new NoViableAltException(
LT(1), getFilename());
242 translationUnit_AST = (
TNode)currentAST.root;
244 catch (RecognitionException ex) {
245 if (inputState.guessing==0) {
252 returnAST = translationUnit_AST;
255 public final void externalList() throws RecognitionException, TokenStreamException {
258 ASTPair currentAST =
new ASTPair();
259 TNode externalList_AST =
null;
268 astFactory.addASTChild(currentAST, returnAST);
271 if ( _cnt209>=1 ) {
break _loop209; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
277 externalList_AST = (
TNode)currentAST.root;
279 catch (RecognitionException ex) {
280 if (inputState.guessing==0) {
287 returnAST = externalList_AST;
290 public final void asm_expr() throws RecognitionException, TokenStreamException {
293 ASTPair currentAST =
new ASTPair();
294 TNode asm_expr_AST =
null;
297 TNode tmp1_AST =
null;
298 tmp1_AST = (
TNode)astFactory.create(
LT(1));
299 astFactory.makeASTRoot(currentAST, tmp1_AST);
305 TNode tmp2_AST =
null;
306 tmp2_AST = (
TNode)astFactory.create(
LT(1));
307 astFactory.addASTChild(currentAST, tmp2_AST);
317 throw new NoViableAltException(
LT(1), getFilename());
321 TNode tmp3_AST =
null;
322 tmp3_AST = (
TNode)astFactory.create(
LT(1));
323 astFactory.addASTChild(currentAST, tmp3_AST);
326 astFactory.addASTChild(currentAST, returnAST);
327 TNode tmp4_AST =
null;
328 tmp4_AST = (
TNode)astFactory.create(
LT(1));
329 astFactory.addASTChild(currentAST, tmp4_AST);
336 TNode tmp5_AST =
null;
337 tmp5_AST = (
TNode)astFactory.create(
LT(1));
338 astFactory.addASTChild(currentAST, tmp5_AST);
342 if ( _cnt6>=1 ) {
break _loop6; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
348 asm_expr_AST = (
TNode)currentAST.root;
350 catch (RecognitionException ex) {
351 if (inputState.guessing==0) {
358 returnAST = asm_expr_AST;
361 public final void expr() throws RecognitionException, TokenStreamException {
364 ASTPair currentAST =
new ASTPair();
365 TNode expr_AST =
null;
371 astFactory.addASTChild(currentAST, returnAST);
377 c_AST = (
TNode)astFactory.create(c);
378 astFactory.makeASTRoot(currentAST, c_AST);
380 if ( inputState.guessing==0 ) {
384 astFactory.addASTChild(currentAST, returnAST);
392 expr_AST = (
TNode)currentAST.root;
394 catch (RecognitionException ex) {
395 if (inputState.guessing==0) {
402 returnAST = expr_AST;
405 public final void idList() throws RecognitionException, TokenStreamException {
408 ASTPair currentAST =
new ASTPair();
409 TNode idList_AST =
null;
412 TNode tmp6_AST =
null;
413 tmp6_AST = (
TNode)astFactory.create(
LT(1));
414 astFactory.addASTChild(currentAST, tmp6_AST);
419 if ((LA(1)==
COMMA) && (LA(2)==
ID)) {
420 TNode tmp7_AST =
null;
421 tmp7_AST = (
TNode)astFactory.create(
LT(1));
422 astFactory.addASTChild(currentAST, tmp7_AST);
424 TNode tmp8_AST =
null;
425 tmp8_AST = (
TNode)astFactory.create(
LT(1));
426 astFactory.addASTChild(currentAST, tmp8_AST);
435 idList_AST = (
TNode)currentAST.root;
437 catch (RecognitionException ex) {
438 if (inputState.guessing==0) {
445 returnAST = idList_AST;
448 public final void externalDef() throws RecognitionException, TokenStreamException {
451 ASTPair currentAST =
new ASTPair();
452 TNode externalDef_AST =
null;
459 astFactory.addASTChild(currentAST, returnAST);
460 externalDef_AST = (
TNode)currentAST.root;
465 TNode tmp9_AST =
null;
466 tmp9_AST = (
TNode)astFactory.create(
LT(1));
467 astFactory.addASTChild(currentAST, tmp9_AST);
469 externalDef_AST = (
TNode)currentAST.root;
473 boolean synPredMatched12 =
false;
476 synPredMatched12 =
true;
477 inputState.guessing++;
487 throw new NoViableAltException(
LT(1), getFilename());
492 catch (RecognitionException pe) {
493 synPredMatched12 =
false;
496inputState.guessing--;
498 if ( synPredMatched12 ) {
500 astFactory.addASTChild(currentAST, returnAST);
501 externalDef_AST = (
TNode)currentAST.root;
504 boolean synPredMatched14 =
false;
507 synPredMatched14 =
true;
508 inputState.guessing++;
514 catch (RecognitionException pe) {
515 synPredMatched14 =
false;
518inputState.guessing--;
520 if ( synPredMatched14 ) {
522 astFactory.addASTChild(currentAST, returnAST);
523 externalDef_AST = (
TNode)currentAST.root;
527 astFactory.addASTChild(currentAST, returnAST);
528 externalDef_AST = (
TNode)currentAST.root;
531 throw new NoViableAltException(
LT(1), getFilename());
535 catch (RecognitionException ex) {
536 if (inputState.guessing==0) {
543 returnAST = externalDef_AST;
546 public final void declaration() throws RecognitionException, TokenStreamException {
549 ASTPair currentAST =
new ASTPair();
550 TNode declaration_AST =
null;
556 ds_AST = (
TNode)returnAST;
557 astFactory.addASTChild(currentAST, returnAST);
558 if ( inputState.guessing==0 ) {
559 ds1 = astFactory.dupList(ds_AST);
568 astFactory.addASTChild(currentAST, returnAST);
577 throw new NoViableAltException(
LT(1), getFilename());
586 TNode tmp10_AST =
null;
587 tmp10_AST = (
TNode)astFactory.create(
LT(1));
588 astFactory.addASTChild(currentAST, tmp10_AST);
592 if ( _cnt78>=1 ) {
break _loop78; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
598 if ( inputState.guessing==0 ) {
599 declaration_AST = (
TNode)currentAST.root;
600 declaration_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NDeclaration)).add(declaration_AST));
601 currentAST.root = declaration_AST;
602 currentAST.child = declaration_AST!=
null &&declaration_AST.getFirstChild()!=
null ?
603 declaration_AST.getFirstChild() : declaration_AST;
604 currentAST.advanceChildToEnd();
606 declaration_AST = (
TNode)currentAST.root;
608 catch (RecognitionException ex) {
609 if (inputState.guessing==0) {
616 returnAST = declaration_AST;
619 public final void functionPrefix() throws RecognitionException, TokenStreamException {
622 ASTPair currentAST =
new ASTPair();
623 TNode functionPrefix_AST =
null;
630 boolean synPredMatched18 =
false;
633 synPredMatched18 =
true;
634 inputState.guessing++;
640 catch (RecognitionException pe) {
641 synPredMatched18 =
false;
644inputState.guessing--;
646 if ( synPredMatched18 ) {
648 ds_AST = (
TNode)returnAST;
649 astFactory.addASTChild(currentAST, returnAST);
654 throw new NoViableAltException(
LT(1), getFilename());
659 d_AST = (
TNode)returnAST;
660 astFactory.addASTChild(currentAST, returnAST);
666 astFactory.addASTChild(currentAST, returnAST);
678 TNode tmp11_AST =
null;
679 tmp11_AST = (
TNode)astFactory.create(
LT(1));
680 astFactory.addASTChild(currentAST, tmp11_AST);
691 throw new NoViableAltException(
LT(1), getFilename());
699 TNode tmp12_AST =
null;
700 tmp12_AST = (
TNode)astFactory.create(
LT(1));
701 astFactory.addASTChild(currentAST, tmp12_AST);
710 TNode tmp13_AST =
null;
711 tmp13_AST = (
TNode)astFactory.create(
LT(1));
712 astFactory.addASTChild(currentAST, tmp13_AST);
714 functionPrefix_AST = (
TNode)currentAST.root;
716 catch (RecognitionException ex) {
717 if (inputState.guessing==0) {
724 returnAST = functionPrefix_AST;
727 public final void functionDef() throws RecognitionException, TokenStreamException {
730 ASTPair currentAST =
new ASTPair();
731 TNode functionDef_AST =
null;
738 boolean synPredMatched241 =
false;
741 synPredMatched241 =
true;
742 inputState.guessing++;
748 catch (RecognitionException pe) {
749 synPredMatched241 =
false;
752inputState.guessing--;
754 if ( synPredMatched241 ) {
756 ds_AST = (
TNode)returnAST;
757 astFactory.addASTChild(currentAST, returnAST);
762 throw new NoViableAltException(
LT(1), getFilename());
767 d_AST = (
TNode)returnAST;
768 astFactory.addASTChild(currentAST, returnAST);
769 if ( inputState.guessing==0 ) {
772 d2 = astFactory.dupList(d_AST);
773 ds2 = astFactory.dupList(ds_AST);
774 symbolTable.
add(declName, (
TNode)astFactory.make( (
new ASTArray(3)).add(
null).add(ds2).add(d2)));
783 astFactory.addASTChild(currentAST, returnAST);
795 TNode tmp14_AST =
null;
796 tmp14_AST = (
TNode)astFactory.create(
LT(1));
797 astFactory.addASTChild(currentAST, tmp14_AST);
808 throw new NoViableAltException(
LT(1), getFilename());
824 if ( inputState.guessing==0 ) {
828 astFactory.addASTChild(currentAST, returnAST);
829 if ( inputState.guessing==0 ) {
830 functionDef_AST = (
TNode)currentAST.root;
831 functionDef_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NFunctionDef)).add(functionDef_AST));
832 currentAST.root = functionDef_AST;
833 currentAST.child = functionDef_AST!=
null &&functionDef_AST.getFirstChild()!=
null ?
834 functionDef_AST.getFirstChild() : functionDef_AST;
835 currentAST.advanceChildToEnd();
837 functionDef_AST = (
TNode)currentAST.root;
839 catch (RecognitionException ex) {
840 if (inputState.guessing==0) {
847 returnAST = functionDef_AST;
853 ASTPair currentAST =
new ASTPair();
854 TNode typelessDeclaration_AST =
null;
859 astFactory.addASTChild(currentAST, returnAST);
860 TNode tmp16_AST =
null;
861 tmp16_AST = (
TNode)astFactory.create(
LT(1));
862 astFactory.addASTChild(currentAST, tmp16_AST);
864 if ( inputState.guessing==0 ) {
865 typelessDeclaration_AST = (
TNode)currentAST.root;
866 typelessDeclaration_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NTypeMissing)).add(typelessDeclaration_AST));
867 currentAST.root = typelessDeclaration_AST;
868 currentAST.child = typelessDeclaration_AST!=
null &&typelessDeclaration_AST.getFirstChild()!=
null ?
869 typelessDeclaration_AST.getFirstChild() : typelessDeclaration_AST;
870 currentAST.advanceChildToEnd();
872 typelessDeclaration_AST = (
TNode)currentAST.root;
874 catch (RecognitionException ex) {
875 if (inputState.guessing==0) {
882 returnAST = typelessDeclaration_AST;
888 ASTPair currentAST =
new ASTPair();
889 TNode functionDeclSpecifiers_AST =
null;
903 astFactory.addASTChild(currentAST, returnAST);
910 astFactory.addASTChild(currentAST, returnAST);
914 boolean synPredMatched250 =
false;
917 synPredMatched250 =
true;
918 inputState.guessing++;
934 throw new NoViableAltException(
LT(1), getFilename());
939 catch (RecognitionException pe) {
940 synPredMatched250 =
false;
943inputState.guessing--;
945 if ( synPredMatched250 ) {
947 astFactory.addASTChild(currentAST, returnAST);
950 if ( _cnt251>=1 ) {
break _loop251; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
956 functionDeclSpecifiers_AST = (
TNode)currentAST.root;
958 catch (RecognitionException ex) {
959 if (inputState.guessing==0) {
966 returnAST = functionDeclSpecifiers_AST;
970 boolean isFunctionDefinition
971 )
throws RecognitionException, TokenStreamException {
975 ASTPair currentAST =
new ASTPair();
976 TNode declarator_AST =
null;
987 astFactory.addASTChild(currentAST, returnAST);
997 throw new NoViableAltException(
LT(1), getFilename());
1006 id_AST = (
TNode)astFactory.create(
id);
1007 astFactory.addASTChild(currentAST, id_AST);
1009 if ( inputState.guessing==0 ) {
1010 declName =
id.getText();
1016 TNode tmp17_AST =
null;
1017 tmp17_AST = (
TNode)astFactory.create(
LT(1));
1018 astFactory.addASTChild(currentAST, tmp17_AST);
1021 astFactory.addASTChild(currentAST, returnAST);
1022 TNode tmp18_AST =
null;
1023 tmp18_AST = (
TNode)astFactory.create(
LT(1));
1024 astFactory.addASTChild(currentAST, tmp18_AST);
1030 throw new NoViableAltException(
LT(1), getFilename());
1041 astFactory.addASTChild(currentAST, returnAST);
1046 TNode tmp19_AST =
null;
1047 tmp19_AST = (
TNode)astFactory.create(
LT(1));
1048 astFactory.addASTChild(currentAST, tmp19_AST);
1073 astFactory.addASTChild(currentAST, returnAST);
1082 throw new NoViableAltException(
LT(1), getFilename());
1086 TNode tmp20_AST =
null;
1087 tmp20_AST = (
TNode)astFactory.create(
LT(1));
1088 astFactory.addASTChild(currentAST, tmp20_AST);
1099 if ( inputState.guessing==0 ) {
1100 declarator_AST = (
TNode)currentAST.root;
1101 declarator_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NDeclarator)).add(declarator_AST));
1102 currentAST.root = declarator_AST;
1103 currentAST.child = declarator_AST!=
null &&declarator_AST.getFirstChild()!=
null ?
1104 declarator_AST.getFirstChild() : declarator_AST;
1105 currentAST.advanceChildToEnd();
1107 declarator_AST = (
TNode)currentAST.root;
1109 catch (RecognitionException ex) {
1110 if (inputState.guessing==0) {
1117 returnAST = declarator_AST;
1122 AST declarationSpecifiers
1123 )
throws RecognitionException, TokenStreamException {
1126 ASTPair currentAST =
new ASTPair();
1127 TNode initDeclList_AST =
null;
1131 astFactory.addASTChild(currentAST, returnAST);
1138 astFactory.addASTChild(currentAST, returnAST);
1159 throw new NoViableAltException(
LT(1), getFilename());
1163 initDeclList_AST = (
TNode)currentAST.root;
1165 catch (RecognitionException ex) {
1166 if (inputState.guessing==0) {
1173 returnAST = initDeclList_AST;
1176 public final void initializer() throws RecognitionException, TokenStreamException {
1179 ASTPair currentAST =
new ASTPair();
1180 TNode initializer_AST =
null;
1187 boolean synPredMatched30 =
false;
1190 synPredMatched30 =
true;
1191 inputState.guessing++;
1197 catch (RecognitionException pe) {
1198 synPredMatched30 =
false;
1201inputState.guessing--;
1203 if ( synPredMatched30 ) {
1205 astFactory.addASTChild(currentAST, returnAST);
1210 throw new NoViableAltException(
LT(1), getFilename());
1237 astFactory.addASTChild(currentAST, returnAST);
1243 astFactory.addASTChild(currentAST, returnAST);
1248 throw new NoViableAltException(
LT(1), getFilename());
1252 if ( inputState.guessing==0 ) {
1253 initializer_AST = (
TNode)currentAST.root;
1254 initializer_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NInitializer)).add(initializer_AST));
1255 currentAST.root = initializer_AST;
1256 currentAST.child = initializer_AST!=
null &&initializer_AST.getFirstChild()!=
null ?
1257 initializer_AST.getFirstChild() : initializer_AST;
1258 currentAST.advanceChildToEnd();
1264 astFactory.addASTChild(currentAST, returnAST);
1267 throw new NoViableAltException(
LT(1), getFilename());
1271 initializer_AST = (
TNode)currentAST.root;
1273 catch (RecognitionException ex) {
1274 if (inputState.guessing==0) {
1281 returnAST = initializer_AST;
1287 ASTPair currentAST =
new ASTPair();
1288 TNode initializerElementLabel_AST =
null;
1296 TNode tmp23_AST =
null;
1297 tmp23_AST = (
TNode)astFactory.create(
LT(1));
1298 astFactory.addASTChild(currentAST, tmp23_AST);
1301 boolean synPredMatched37 =
false;
1304 synPredMatched37 =
true;
1305 inputState.guessing++;
1312 catch (RecognitionException pe) {
1313 synPredMatched37 =
false;
1316inputState.guessing--;
1318 if ( synPredMatched37 ) {
1320 astFactory.addASTChild(currentAST, returnAST);
1324 astFactory.addASTChild(currentAST, returnAST);
1327 throw new NoViableAltException(
LT(1), getFilename());
1331 TNode tmp24_AST =
null;
1332 tmp24_AST = (
TNode)astFactory.create(
LT(1));
1333 astFactory.addASTChild(currentAST, tmp24_AST);
1339 TNode tmp25_AST =
null;
1340 tmp25_AST = (
TNode)astFactory.create(
LT(1));
1341 astFactory.addASTChild(currentAST, tmp25_AST);
1370 throw new NoViableAltException(
LT(1), getFilename());
1379 TNode tmp26_AST =
null;
1380 tmp26_AST = (
TNode)astFactory.create(
LT(1));
1381 astFactory.addASTChild(currentAST, tmp26_AST);
1383 TNode tmp27_AST =
null;
1384 tmp27_AST = (
TNode)astFactory.create(
LT(1));
1385 astFactory.addASTChild(currentAST, tmp27_AST);
1391 TNode tmp28_AST =
null;
1392 tmp28_AST = (
TNode)astFactory.create(
LT(1));
1393 astFactory.addASTChild(currentAST, tmp28_AST);
1395 TNode tmp29_AST =
null;
1396 tmp29_AST = (
TNode)astFactory.create(
LT(1));
1397 astFactory.addASTChild(currentAST, tmp29_AST);
1399 TNode tmp30_AST =
null;
1400 tmp30_AST = (
TNode)astFactory.create(
LT(1));
1401 astFactory.addASTChild(currentAST, tmp30_AST);
1407 throw new NoViableAltException(
LT(1), getFilename());
1411 if ( inputState.guessing==0 ) {
1412 initializerElementLabel_AST = (
TNode)currentAST.root;
1414 currentAST.root = initializerElementLabel_AST;
1415 currentAST.child = initializerElementLabel_AST!=
null &&initializerElementLabel_AST.getFirstChild()!=
null ?
1416 initializerElementLabel_AST.getFirstChild() : initializerElementLabel_AST;
1417 currentAST.advanceChildToEnd();
1419 initializerElementLabel_AST = (
TNode)currentAST.root;
1421 catch (RecognitionException ex) {
1422 if (inputState.guessing==0) {
1429 returnAST = initializerElementLabel_AST;
1432 public final void assignExpr() throws RecognitionException, TokenStreamException {
1435 ASTPair currentAST =
new ASTPair();
1436 TNode assignExpr_AST =
null;
1441 astFactory.addASTChild(currentAST, returnAST);
1457 a_AST = (
TNode)returnAST;
1459 astFactory.addASTChild(currentAST, returnAST);
1460 if ( inputState.guessing==0 ) {
1461 assignExpr_AST = (
TNode)currentAST.root;
1462 assignExpr_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add(a_AST).add(assignExpr_AST));
1463 currentAST.root = assignExpr_AST;
1464 currentAST.child = assignExpr_AST!=
null &&assignExpr_AST.getFirstChild()!=
null ?
1465 assignExpr_AST.getFirstChild() : assignExpr_AST;
1466 currentAST.advanceChildToEnd();
1481 throw new NoViableAltException(
LT(1), getFilename());
1485 assignExpr_AST = (
TNode)currentAST.root;
1487 catch (RecognitionException ex) {
1488 if (inputState.guessing==0) {
1495 returnAST = assignExpr_AST;
1501 ASTPair currentAST =
new ASTPair();
1502 TNode lcurlyInitializer_AST =
null;
1505 TNode tmp31_AST =
null;
1506 tmp31_AST = (
TNode)astFactory.create(
LT(1));
1507 astFactory.makeASTRoot(currentAST, tmp31_AST);
1535 astFactory.addASTChild(currentAST, returnAST);
1549 throw new NoViableAltException(
LT(1), getFilename());
1561 throw new NoViableAltException(
LT(1), getFilename());
1565 TNode tmp33_AST =
null;
1566 tmp33_AST = (
TNode)astFactory.create(
LT(1));
1567 astFactory.addASTChild(currentAST, tmp33_AST);
1569 if ( inputState.guessing==0 ) {
1570 lcurlyInitializer_AST = (
TNode)currentAST.root;
1573 lcurlyInitializer_AST = (
TNode)currentAST.root;
1575 catch (RecognitionException ex) {
1576 if (inputState.guessing==0) {
1583 returnAST = lcurlyInitializer_AST;
1586 public final void constExpr() throws RecognitionException, TokenStreamException {
1589 ASTPair currentAST =
new ASTPair();
1590 TNode constExpr_AST =
null;
1594 astFactory.addASTChild(currentAST, returnAST);
1595 constExpr_AST = (
TNode)currentAST.root;
1597 catch (RecognitionException ex) {
1598 if (inputState.guessing==0) {
1605 returnAST = constExpr_AST;
1608 public final void rangeExpr() throws RecognitionException, TokenStreamException {
1611 ASTPair currentAST =
new ASTPair();
1612 TNode rangeExpr_AST =
null;
1616 astFactory.addASTChild(currentAST, returnAST);
1617 TNode tmp34_AST =
null;
1618 tmp34_AST = (
TNode)astFactory.create(
LT(1));
1619 astFactory.addASTChild(currentAST, tmp34_AST);
1622 astFactory.addASTChild(currentAST, returnAST);
1623 if ( inputState.guessing==0 ) {
1624 rangeExpr_AST = (
TNode)currentAST.root;
1625 rangeExpr_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NRangeExpr)).add(rangeExpr_AST));
1626 currentAST.root = rangeExpr_AST;
1627 currentAST.child = rangeExpr_AST!=
null &&rangeExpr_AST.getFirstChild()!=
null ?
1628 rangeExpr_AST.getFirstChild() : rangeExpr_AST;
1629 currentAST.advanceChildToEnd();
1631 rangeExpr_AST = (
TNode)currentAST.root;
1633 catch (RecognitionException ex) {
1634 if (inputState.guessing==0) {
1641 returnAST = rangeExpr_AST;
1647 ASTPair currentAST =
new ASTPair();
1648 TNode initializerList_AST =
null;
1652 astFactory.addASTChild(currentAST, returnAST);
1659 astFactory.addASTChild(currentAST, returnAST);
1667 initializerList_AST = (
TNode)currentAST.root;
1669 catch (RecognitionException ex) {
1670 if (inputState.guessing==0) {
1677 returnAST = initializerList_AST;
1680 public final void pointerGroup() throws RecognitionException, TokenStreamException {
1683 ASTPair currentAST =
new ASTPair();
1684 TNode pointerGroup_AST =
null;
1691 if ((LA(1)==
STAR)) {
1692 TNode tmp36_AST =
null;
1693 tmp36_AST = (
TNode)astFactory.create(
LT(1));
1694 astFactory.addASTChild(currentAST, tmp36_AST);
1701 astFactory.addASTChild(currentAST, returnAST);
1711 if ( _cnt233>=1 ) {
break _loop233; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
1717 if ( inputState.guessing==0 ) {
1718 pointerGroup_AST = (
TNode)currentAST.root;
1719 pointerGroup_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NPointerGroup)).add(pointerGroup_AST));
1720 currentAST.root = pointerGroup_AST;
1721 currentAST.child = pointerGroup_AST!=
null &&pointerGroup_AST.getFirstChild()!=
null ?
1722 pointerGroup_AST.getFirstChild() : pointerGroup_AST;
1723 currentAST.advanceChildToEnd();
1725 pointerGroup_AST = (
TNode)currentAST.root;
1727 catch (RecognitionException ex) {
1728 if (inputState.guessing==0) {
1735 returnAST = pointerGroup_AST;
1739 boolean isFunctionDefinition, String declName
1740 )
throws RecognitionException, TokenStreamException {
1743 ASTPair currentAST =
new ASTPair();
1744 TNode declaratorParamaterList_AST =
null;
1747 TNode tmp37_AST =
null;
1748 tmp37_AST = (
TNode)astFactory.create(
LT(1));
1749 astFactory.makeASTRoot(currentAST, tmp37_AST);
1751 if ( inputState.guessing==0 ) {
1753 if (isFunctionDefinition) {
1762 boolean synPredMatched54 =
false;
1765 synPredMatched54 =
true;
1766 inputState.guessing++;
1772 catch (RecognitionException pe) {
1773 synPredMatched54 =
false;
1776inputState.guessing--;
1778 if ( synPredMatched54 ) {
1780 astFactory.addASTChild(currentAST, returnAST);
1788 astFactory.addASTChild(currentAST, returnAST);
1798 throw new NoViableAltException(
LT(1), getFilename());
1804 throw new NoViableAltException(
LT(1), getFilename());
1808 if ( inputState.guessing==0 ) {
1826 throw new NoViableAltException(
LT(1), getFilename());
1830 TNode tmp39_AST =
null;
1831 tmp39_AST = (
TNode)astFactory.create(
LT(1));
1832 astFactory.addASTChild(currentAST, tmp39_AST);
1834 if ( inputState.guessing==0 ) {
1835 declaratorParamaterList_AST = (
TNode)currentAST.root;
1838 declaratorParamaterList_AST = (
TNode)currentAST.root;
1840 catch (RecognitionException ex) {
1841 if (inputState.guessing==0) {
1848 returnAST = declaratorParamaterList_AST;
1851 public final void declSpecifiers() throws RecognitionException, TokenStreamException {
1854 ASTPair currentAST =
new ASTPair();
1855 TNode declSpecifiers_AST =
null;
1873 s_AST = (
TNode)returnAST;
1874 astFactory.addASTChild(currentAST, returnAST);
1881 astFactory.addASTChild(currentAST, returnAST);
1885 boolean synPredMatched213 =
false;
1888 synPredMatched213 =
true;
1889 inputState.guessing++;
1905 throw new NoViableAltException(
LT(1), getFilename());
1910 catch (RecognitionException pe) {
1911 synPredMatched213 =
false;
1914inputState.guessing--;
1916 if ( synPredMatched213 ) {
1918 astFactory.addASTChild(currentAST, returnAST);
1921 if ( _cnt214>=1 ) {
break _loop214; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
1927 declSpecifiers_AST = (
TNode)currentAST.root;
1929 catch (RecognitionException ex) {
1930 if (inputState.guessing==0) {
1937 returnAST = declSpecifiers_AST;
1943 ASTPair currentAST =
new ASTPair();
1944 TNode parameterTypeList_AST =
null;
1948 astFactory.addASTChild(currentAST, returnAST);
1957 TNode tmp40_AST =
null;
1958 tmp40_AST = (
TNode)astFactory.create(
LT(1));
1959 astFactory.addASTChild(currentAST, tmp40_AST);
1965 TNode tmp41_AST =
null;
1966 tmp41_AST = (
TNode)astFactory.create(
LT(1));
1967 astFactory.addASTChild(currentAST, tmp41_AST);
1973 throw new NoViableAltException(
LT(1), getFilename());
1978 astFactory.addASTChild(currentAST, returnAST);
1992 TNode tmp42_AST =
null;
1993 tmp42_AST = (
TNode)astFactory.create(
LT(1));
1994 astFactory.addASTChild(currentAST, tmp42_AST);
2000 TNode tmp43_AST =
null;
2001 tmp43_AST = (
TNode)astFactory.create(
LT(1));
2002 astFactory.addASTChild(currentAST, tmp43_AST);
2008 throw new NoViableAltException(
LT(1), getFilename());
2012 TNode tmp44_AST =
null;
2013 tmp44_AST = (
TNode)astFactory.create(
LT(1));
2014 astFactory.addASTChild(currentAST, tmp44_AST);
2020 throw new NoViableAltException(
LT(1), getFilename());
2024 parameterTypeList_AST = (
TNode)currentAST.root;
2026 catch (RecognitionException ex) {
2027 if (inputState.guessing==0) {
2034 returnAST = parameterTypeList_AST;
2040 ASTPair currentAST =
new ASTPair();
2041 TNode parameterDeclaration_AST =
null;
2042 TNode ds_AST =
null;
2048 ds_AST = (
TNode)returnAST;
2049 astFactory.addASTChild(currentAST, returnAST);
2051 boolean synPredMatched237 =
false;
2054 synPredMatched237 =
true;
2055 inputState.guessing++;
2061 catch (RecognitionException pe) {
2062 synPredMatched237 =
false;
2065inputState.guessing--;
2067 if ( synPredMatched237 ) {
2069 d_AST = (
TNode)returnAST;
2070 astFactory.addASTChild(currentAST, returnAST);
2071 if ( inputState.guessing==0 ) {
2074 d2 = astFactory.dupList(d_AST);
2075 ds2 = astFactory.dupList(ds_AST);
2076 symbolTable.
add(declName, (
TNode)astFactory.make( (
new ASTArray(3)).add(
null).add(ds2).add(d2)));
2082 astFactory.addASTChild(currentAST, returnAST);
2087 throw new NoViableAltException(
LT(1), getFilename());
2091 if ( inputState.guessing==0 ) {
2092 parameterDeclaration_AST = (
TNode)currentAST.root;
2094 parameterDeclaration_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NParameterDeclaration)).add(parameterDeclaration_AST));
2096 currentAST.root = parameterDeclaration_AST;
2097 currentAST.child = parameterDeclaration_AST!=
null &¶meterDeclaration_AST.getFirstChild()!=
null ?
2098 parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST;
2099 currentAST.advanceChildToEnd();
2101 parameterDeclaration_AST = (
TNode)currentAST.root;
2103 catch (RecognitionException ex) {
2104 if (inputState.guessing==0) {
2111 returnAST = parameterDeclaration_AST;
2117 ASTPair currentAST =
new ASTPair();
2118 TNode declarationList_AST =
null;
2127 astFactory.addASTChild(currentAST, returnAST);
2130 boolean synPredMatched66 =
false;
2133 synPredMatched66 =
true;
2134 inputState.guessing++;
2140 catch (RecognitionException pe) {
2141 synPredMatched66 =
false;
2144inputState.guessing--;
2146 if ( synPredMatched66 ) {
2148 astFactory.addASTChild(currentAST, returnAST);
2151 if ( _cnt67>=1 ) {
break _loop67; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
2157 declarationList_AST = (
TNode)currentAST.root;
2159 catch (RecognitionException ex) {
2160 if (inputState.guessing==0) {
2167 returnAST = declarationList_AST;
2173 ASTPair currentAST =
new ASTPair();
2174 TNode localLabelDeclaration_AST =
null;
2178 TNode tmp45_AST =
null;
2179 tmp45_AST = (
TNode)astFactory.create(
LT(1));
2180 astFactory.makeASTRoot(currentAST, tmp45_AST);
2182 TNode tmp46_AST =
null;
2183 tmp46_AST = (
TNode)astFactory.create(
LT(1));
2184 astFactory.addASTChild(currentAST, tmp46_AST);
2189 if ((LA(1)==
COMMA) && (LA(2)==
ID)) {
2191 TNode tmp48_AST =
null;
2192 tmp48_AST = (
TNode)astFactory.create(
LT(1));
2193 astFactory.addASTChild(currentAST, tmp48_AST);
2215 throw new NoViableAltException(
LT(1), getFilename());
2227 if ( _cnt74>=1 ) {
break _loop74; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
2234 localLabelDeclaration_AST = (
TNode)currentAST.root;
2236 catch (RecognitionException ex) {
2237 if (inputState.guessing==0) {
2244 returnAST = localLabelDeclaration_AST;
2250 ASTPair currentAST =
new ASTPair();
2251 TNode declarationPredictor_AST =
null;
2256 TNode tmp51_AST =
null;
2257 tmp51_AST = (
TNode)astFactory.create(
LT(1));
2258 astFactory.addASTChild(currentAST, tmp51_AST);
2263 astFactory.addASTChild(currentAST, returnAST);
2266 throw new NoViableAltException(
LT(1), getFilename());
2270 declarationPredictor_AST = (
TNode)currentAST.root;
2272 catch (RecognitionException ex) {
2273 if (inputState.guessing==0) {
2280 returnAST = declarationPredictor_AST;
2286 ASTPair currentAST =
new ASTPair();
2287 TNode functionStorageClassSpecifier_AST =
null;
2293 TNode tmp52_AST =
null;
2294 tmp52_AST = (
TNode)astFactory.create(
LT(1));
2295 astFactory.addASTChild(currentAST, tmp52_AST);
2297 functionStorageClassSpecifier_AST = (
TNode)currentAST.root;
2302 TNode tmp53_AST =
null;
2303 tmp53_AST = (
TNode)astFactory.create(
LT(1));
2304 astFactory.addASTChild(currentAST, tmp53_AST);
2306 functionStorageClassSpecifier_AST = (
TNode)currentAST.root;
2311 TNode tmp54_AST =
null;
2312 tmp54_AST = (
TNode)astFactory.create(
LT(1));
2313 astFactory.addASTChild(currentAST, tmp54_AST);
2315 functionStorageClassSpecifier_AST = (
TNode)currentAST.root;
2320 throw new NoViableAltException(
LT(1), getFilename());
2324 catch (RecognitionException ex) {
2325 if (inputState.guessing==0) {
2332 returnAST = functionStorageClassSpecifier_AST;
2337 )
throws RecognitionException, TokenStreamException {
2341 ASTPair currentAST =
new ASTPair();
2342 TNode typeSpecifier_AST =
null;
2343 retSpecCount = specCount + 1;
2350 TNode tmp55_AST =
null;
2351 tmp55_AST = (
TNode)astFactory.create(
LT(1));
2352 astFactory.addASTChild(currentAST, tmp55_AST);
2358 TNode tmp56_AST =
null;
2359 tmp56_AST = (
TNode)astFactory.create(
LT(1));
2360 astFactory.addASTChild(currentAST, tmp56_AST);
2366 TNode tmp57_AST =
null;
2367 tmp57_AST = (
TNode)astFactory.create(
LT(1));
2368 astFactory.addASTChild(currentAST, tmp57_AST);
2374 TNode tmp58_AST =
null;
2375 tmp58_AST = (
TNode)astFactory.create(
LT(1));
2376 astFactory.addASTChild(currentAST, tmp58_AST);
2382 TNode tmp59_AST =
null;
2383 tmp59_AST = (
TNode)astFactory.create(
LT(1));
2384 astFactory.addASTChild(currentAST, tmp59_AST);
2390 TNode tmp60_AST =
null;
2391 tmp60_AST = (
TNode)astFactory.create(
LT(1));
2392 astFactory.addASTChild(currentAST, tmp60_AST);
2398 TNode tmp61_AST =
null;
2399 tmp61_AST = (
TNode)astFactory.create(
LT(1));
2400 astFactory.addASTChild(currentAST, tmp61_AST);
2406 TNode tmp62_AST =
null;
2407 tmp62_AST = (
TNode)astFactory.create(
LT(1));
2408 astFactory.addASTChild(currentAST, tmp62_AST);
2414 TNode tmp63_AST =
null;
2415 tmp63_AST = (
TNode)astFactory.create(
LT(1));
2416 astFactory.addASTChild(currentAST, tmp63_AST);
2422 TNode tmp64_AST =
null;
2423 tmp64_AST = (
TNode)astFactory.create(
LT(1));
2424 astFactory.addASTChild(currentAST, tmp64_AST);
2430 TNode tmp65_AST =
null;
2431 tmp65_AST = (
TNode)astFactory.create(
LT(1));
2432 astFactory.addASTChild(currentAST, tmp65_AST);
2438 TNode tmp66_AST =
null;
2439 tmp66_AST = (
TNode)astFactory.create(
LT(1));
2440 astFactory.addASTChild(currentAST, tmp66_AST);
2446 TNode tmp67_AST =
null;
2447 tmp67_AST = (
TNode)astFactory.create(
LT(1));
2448 astFactory.addASTChild(currentAST, tmp67_AST);
2454 TNode tmp68_AST =
null;
2455 tmp68_AST = (
TNode)astFactory.create(
LT(1));
2456 astFactory.addASTChild(currentAST, tmp68_AST);
2462 TNode tmp69_AST =
null;
2463 tmp69_AST = (
TNode)astFactory.create(
LT(1));
2464 astFactory.addASTChild(currentAST, tmp69_AST);
2470 TNode tmp70_AST =
null;
2471 tmp70_AST = (
TNode)astFactory.create(
LT(1));
2472 astFactory.addASTChild(currentAST, tmp70_AST);
2478 TNode tmp71_AST =
null;
2479 tmp71_AST = (
TNode)astFactory.create(
LT(1));
2480 astFactory.addASTChild(currentAST, tmp71_AST);
2486 TNode tmp72_AST =
null;
2487 tmp72_AST = (
TNode)astFactory.create(
LT(1));
2488 astFactory.addASTChild(currentAST, tmp72_AST);
2494 TNode tmp73_AST =
null;
2495 tmp73_AST = (
TNode)astFactory.create(
LT(1));
2496 astFactory.addASTChild(currentAST, tmp73_AST);
2502 TNode tmp74_AST =
null;
2503 tmp74_AST = (
TNode)astFactory.create(
LT(1));
2504 astFactory.addASTChild(currentAST, tmp74_AST);
2510 TNode tmp75_AST =
null;
2511 tmp75_AST = (
TNode)astFactory.create(
LT(1));
2512 astFactory.addASTChild(currentAST, tmp75_AST);
2518 TNode tmp76_AST =
null;
2519 tmp76_AST = (
TNode)astFactory.create(
LT(1));
2520 astFactory.addASTChild(currentAST, tmp76_AST);
2526 TNode tmp77_AST =
null;
2527 tmp77_AST = (
TNode)astFactory.create(
LT(1));
2528 astFactory.addASTChild(currentAST, tmp77_AST);
2534 TNode tmp78_AST =
null;
2535 tmp78_AST = (
TNode)astFactory.create(
LT(1));
2536 astFactory.addASTChild(currentAST, tmp78_AST);
2544 astFactory.addASTChild(currentAST, returnAST);
2550 astFactory.addASTChild(currentAST, returnAST);
2563 astFactory.addASTChild(currentAST, returnAST);
2568 TNode tmp79_AST =
null;
2569 tmp79_AST = (
TNode)astFactory.create(
LT(1));
2570 astFactory.makeASTRoot(currentAST, tmp79_AST);
2572 TNode tmp80_AST =
null;
2573 tmp80_AST = (
TNode)astFactory.create(
LT(1));
2574 astFactory.addASTChild(currentAST, tmp80_AST);
2577 boolean synPredMatched86 =
false;
2580 synPredMatched86 =
true;
2581 inputState.guessing++;
2587 catch (RecognitionException pe) {
2588 synPredMatched86 =
false;
2591inputState.guessing--;
2593 if ( synPredMatched86 ) {
2595 astFactory.addASTChild(currentAST, returnAST);
2599 astFactory.addASTChild(currentAST, returnAST);
2602 throw new NoViableAltException(
LT(1), getFilename());
2606 TNode tmp81_AST =
null;
2607 tmp81_AST = (
TNode)astFactory.create(
LT(1));
2608 astFactory.addASTChild(currentAST, tmp81_AST);
2614 TNode tmp82_AST =
null;
2615 tmp82_AST = (
TNode)astFactory.create(
LT(1));
2616 astFactory.addASTChild(currentAST, tmp82_AST);
2621 if (((LA(1)==
ID))&&( specCount==0 )) {
2623 astFactory.addASTChild(currentAST, returnAST);
2626 throw new NoViableAltException(
LT(1), getFilename());
2630 typeSpecifier_AST = (
TNode)currentAST.root;
2632 catch (RecognitionException ex) {
2633 if (inputState.guessing==0) {
2640 returnAST = typeSpecifier_AST;
2641 return retSpecCount;
2647 ASTPair currentAST =
new ASTPair();
2648 TNode structOrUnionSpecifier_AST =
null;
2649 TNode sou_AST =
null;
2655 TNode l1_AST =
null;
2660 sou_AST = (
TNode)returnAST;
2662 boolean synPredMatched90 =
false;
2663 if (((LA(1)==
ID) && (LA(2)==
LCURLY))) {
2665 synPredMatched90 =
true;
2666 inputState.guessing++;
2673 catch (RecognitionException pe) {
2674 synPredMatched90 =
false;
2677inputState.guessing--;
2679 if ( synPredMatched90 ) {
2681 i_AST = (
TNode)astFactory.create(i);
2682 astFactory.addASTChild(currentAST, i_AST);
2685 l_AST = (
TNode)astFactory.create(l);
2686 astFactory.addASTChild(currentAST, l_AST);
2688 if ( inputState.guessing==0 ) {
2731 astFactory.addASTChild(currentAST, returnAST);
2740 throw new NoViableAltException(
LT(1), getFilename());
2744 if ( inputState.guessing==0 ) {
2747 TNode tmp83_AST =
null;
2748 tmp83_AST = (
TNode)astFactory.create(
LT(1));
2749 astFactory.addASTChild(currentAST, tmp83_AST);
2752 else if ((LA(1)==
LCURLY)) {
2754 l1_AST = (
TNode)astFactory.create(l1);
2755 astFactory.addASTChild(currentAST, l1_AST);
2757 if ( inputState.guessing==0 ) {
2800 astFactory.addASTChild(currentAST, returnAST);
2809 throw new NoViableAltException(
LT(1), getFilename());
2813 if ( inputState.guessing==0 ) {
2816 TNode tmp84_AST =
null;
2817 tmp84_AST = (
TNode)astFactory.create(
LT(1));
2818 astFactory.addASTChild(currentAST, tmp84_AST);
2822 TNode tmp85_AST =
null;
2823 tmp85_AST = (
TNode)astFactory.create(
LT(1));
2824 astFactory.addASTChild(currentAST, tmp85_AST);
2828 throw new NoViableAltException(
LT(1), getFilename());
2832 if ( inputState.guessing==0 ) {
2833 structOrUnionSpecifier_AST = (
TNode)currentAST.root;
2835 structOrUnionSpecifier_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add(sou_AST).add(structOrUnionSpecifier_AST));
2837 currentAST.root = structOrUnionSpecifier_AST;
2838 currentAST.child = structOrUnionSpecifier_AST!=
null &&structOrUnionSpecifier_AST.getFirstChild()!=
null ?
2839 structOrUnionSpecifier_AST.getFirstChild() : structOrUnionSpecifier_AST;
2840 currentAST.advanceChildToEnd();
2842 structOrUnionSpecifier_AST = (
TNode)currentAST.root;
2844 catch (RecognitionException ex) {
2845 if (inputState.guessing==0) {
2852 returnAST = structOrUnionSpecifier_AST;
2855 public final void attributeDecl() throws RecognitionException, TokenStreamException {
2858 ASTPair currentAST =
new ASTPair();
2859 TNode attributeDecl_AST =
null;
2865 TNode tmp86_AST =
null;
2866 tmp86_AST = (
TNode)astFactory.create(
LT(1));
2867 astFactory.makeASTRoot(currentAST, tmp86_AST);
2869 TNode tmp87_AST =
null;
2870 tmp87_AST = (
TNode)astFactory.create(
LT(1));
2871 astFactory.addASTChild(currentAST, tmp87_AST);
2873 TNode tmp88_AST =
null;
2874 tmp88_AST = (
TNode)astFactory.create(
LT(1));
2875 astFactory.addASTChild(currentAST, tmp88_AST);
2878 astFactory.addASTChild(currentAST, returnAST);
2879 TNode tmp89_AST =
null;
2880 tmp89_AST = (
TNode)astFactory.create(
LT(1));
2881 astFactory.addASTChild(currentAST, tmp89_AST);
2883 TNode tmp90_AST =
null;
2884 tmp90_AST = (
TNode)astFactory.create(
LT(1));
2885 astFactory.addASTChild(currentAST, tmp90_AST);
2887 attributeDecl_AST = (
TNode)currentAST.root;
2892 TNode tmp91_AST =
null;
2893 tmp91_AST = (
TNode)astFactory.create(
LT(1));
2894 astFactory.makeASTRoot(currentAST, tmp91_AST);
2896 TNode tmp92_AST =
null;
2897 tmp92_AST = (
TNode)astFactory.create(
LT(1));
2898 astFactory.addASTChild(currentAST, tmp92_AST);
2901 astFactory.addASTChild(currentAST, returnAST);
2902 TNode tmp93_AST =
null;
2903 tmp93_AST = (
TNode)astFactory.create(
LT(1));
2904 astFactory.addASTChild(currentAST, tmp93_AST);
2906 if ( inputState.guessing==0 ) {
2907 attributeDecl_AST = (
TNode)currentAST.root;
2910 attributeDecl_AST = (
TNode)currentAST.root;
2915 throw new NoViableAltException(
LT(1), getFilename());
2919 catch (RecognitionException ex) {
2920 if (inputState.guessing==0) {
2927 returnAST = attributeDecl_AST;
2930 public final void enumSpecifier() throws RecognitionException, TokenStreamException {
2933 ASTPair currentAST =
new ASTPair();
2934 TNode enumSpecifier_AST =
null;
2939 TNode tmp94_AST =
null;
2940 tmp94_AST = (
TNode)astFactory.create(
LT(1));
2941 astFactory.makeASTRoot(currentAST, tmp94_AST);
2944 boolean synPredMatched108 =
false;
2945 if (((LA(1)==
ID) && (LA(2)==
LCURLY))) {
2947 synPredMatched108 =
true;
2948 inputState.guessing++;
2955 catch (RecognitionException pe) {
2956 synPredMatched108 =
false;
2959inputState.guessing--;
2961 if ( synPredMatched108 ) {
2963 i_AST = (
TNode)astFactory.create(i);
2964 astFactory.addASTChild(currentAST, i_AST);
2966 TNode tmp95_AST =
null;
2967 tmp95_AST = (
TNode)astFactory.create(
LT(1));
2968 astFactory.addASTChild(currentAST, tmp95_AST);
2971 astFactory.addASTChild(currentAST, returnAST);
2972 TNode tmp96_AST =
null;
2973 tmp96_AST = (
TNode)astFactory.create(
LT(1));
2974 astFactory.addASTChild(currentAST, tmp96_AST);
2977 else if ((LA(1)==
LCURLY)) {
2978 TNode tmp97_AST =
null;
2979 tmp97_AST = (
TNode)astFactory.create(
LT(1));
2980 astFactory.addASTChild(currentAST, tmp97_AST);
2983 astFactory.addASTChild(currentAST, returnAST);
2984 TNode tmp98_AST =
null;
2985 tmp98_AST = (
TNode)astFactory.create(
LT(1));
2986 astFactory.addASTChild(currentAST, tmp98_AST);
2990 TNode tmp99_AST =
null;
2991 tmp99_AST = (
TNode)astFactory.create(
LT(1));
2992 astFactory.addASTChild(currentAST, tmp99_AST);
2996 throw new NoViableAltException(
LT(1), getFilename());
3000 enumSpecifier_AST = (
TNode)currentAST.root;
3002 catch (RecognitionException ex) {
3003 if (inputState.guessing==0) {
3010 returnAST = enumSpecifier_AST;
3013 public final void typedefName() throws RecognitionException, TokenStreamException {
3016 ASTPair currentAST =
new ASTPair();
3017 TNode typedefName_AST =
null;
3023 throw new SemanticException(
" isTypedefName ( LT(1).getText() ) ");
3025 i_AST = (
TNode)astFactory.create(i);
3026 astFactory.addASTChild(currentAST, i_AST);
3028 if ( inputState.guessing==0 ) {
3029 typedefName_AST = (
TNode)currentAST.root;
3030 typedefName_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NTypedefName)).add(i_AST));
3031 currentAST.root = typedefName_AST;
3032 currentAST.child = typedefName_AST!=
null &&typedefName_AST.getFirstChild()!=
null ?
3033 typedefName_AST.getFirstChild() : typedefName_AST;
3034 currentAST.advanceChildToEnd();
3036 typedefName_AST = (
TNode)currentAST.root;
3038 catch (RecognitionException ex) {
3039 if (inputState.guessing==0) {
3046 returnAST = typedefName_AST;
3049 public final void typeName() throws RecognitionException, TokenStreamException {
3052 ASTPair currentAST =
new ASTPair();
3053 TNode typeName_AST =
null;
3057 astFactory.addASTChild(currentAST, returnAST);
3065 astFactory.addASTChild(currentAST, returnAST);
3074 throw new NoViableAltException(
LT(1), getFilename());
3078 typeName_AST = (
TNode)currentAST.root;
3080 catch (RecognitionException ex) {
3081 if (inputState.guessing==0) {
3088 returnAST = typeName_AST;
3091 public final void structOrUnion() throws RecognitionException, TokenStreamException {
3094 ASTPair currentAST =
new ASTPair();
3095 TNode structOrUnion_AST =
null;
3101 TNode tmp100_AST =
null;
3102 tmp100_AST = (
TNode)astFactory.create(
LT(1));
3103 astFactory.addASTChild(currentAST, tmp100_AST);
3105 structOrUnion_AST = (
TNode)currentAST.root;
3110 TNode tmp101_AST =
null;
3111 tmp101_AST = (
TNode)astFactory.create(
LT(1));
3112 astFactory.addASTChild(currentAST, tmp101_AST);
3114 structOrUnion_AST = (
TNode)currentAST.root;
3119 throw new NoViableAltException(
LT(1), getFilename());
3123 catch (RecognitionException ex) {
3124 if (inputState.guessing==0) {
3131 returnAST = structOrUnion_AST;
3137 ASTPair currentAST =
new ASTPair();
3138 TNode structDeclarationList_AST =
null;
3147 astFactory.addASTChild(currentAST, returnAST);
3150 if ( _cnt221>=1 ) {
break _loop221; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
3156 structDeclarationList_AST = (
TNode)currentAST.root;
3158 catch (RecognitionException ex) {
3159 if (inputState.guessing==0) {
3166 returnAST = structDeclarationList_AST;
3172 ASTPair currentAST =
new ASTPair();
3173 TNode structDeclaration_AST =
null;
3177 astFactory.addASTChild(currentAST, returnAST);
3179 astFactory.addASTChild(currentAST, returnAST);
3193 throw new NoViableAltException(
LT(1), getFilename());
3201 if ((LA(1)==
SEMI)) {
3205 if ( _cnt96>=1 ) {
break _loop96; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
3211 structDeclaration_AST = (
TNode)currentAST.root;
3213 catch (RecognitionException ex) {
3214 if (inputState.guessing==0) {
3221 returnAST = structDeclaration_AST;
3227 ASTPair currentAST =
new ASTPair();
3228 TNode specifierQualifierList_AST =
null;
3236 boolean synPredMatched225 =
false;
3239 synPredMatched225 =
true;
3240 inputState.guessing++;
3256 throw new NoViableAltException(
LT(1), getFilename());
3261 catch (RecognitionException pe) {
3262 synPredMatched225 =
false;
3265inputState.guessing--;
3267 if ( synPredMatched225 ) {
3269 astFactory.addASTChild(currentAST, returnAST);
3273 astFactory.addASTChild(currentAST, returnAST);
3276 if ( _cnt226>=1 ) {
break _loop226; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
3282 specifierQualifierList_AST = (
TNode)currentAST.root;
3284 catch (RecognitionException ex) {
3285 if (inputState.guessing==0) {
3292 returnAST = specifierQualifierList_AST;
3298 ASTPair currentAST =
new ASTPair();
3299 TNode structDeclaratorList_AST =
null;
3303 astFactory.addASTChild(currentAST, returnAST);
3310 astFactory.addASTChild(currentAST, returnAST);
3318 structDeclaratorList_AST = (
TNode)currentAST.root;
3320 catch (RecognitionException ex) {
3321 if (inputState.guessing==0) {
3328 returnAST = structDeclaratorList_AST;
3334 ASTPair currentAST =
new ASTPair();
3335 TNode structDeclarator_AST =
null;
3345 astFactory.addASTChild(currentAST, returnAST);
3358 throw new NoViableAltException(
LT(1), getFilename());
3366 TNode tmp105_AST =
null;
3367 tmp105_AST = (
TNode)astFactory.create(
LT(1));
3368 astFactory.addASTChild(currentAST, tmp105_AST);
3371 astFactory.addASTChild(currentAST, returnAST);
3383 throw new NoViableAltException(
LT(1), getFilename());
3392 astFactory.addASTChild(currentAST, returnAST);
3400 if ( inputState.guessing==0 ) {
3401 structDeclarator_AST = (
TNode)currentAST.root;
3402 structDeclarator_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NStructDeclarator)).add(structDeclarator_AST));
3403 currentAST.root = structDeclarator_AST;
3404 currentAST.child = structDeclarator_AST!=
null &&structDeclarator_AST.getFirstChild()!=
null ?
3405 structDeclarator_AST.getFirstChild() : structDeclarator_AST;
3406 currentAST.advanceChildToEnd();
3408 structDeclarator_AST = (
TNode)currentAST.root;
3410 catch (RecognitionException ex) {
3411 if (inputState.guessing==0) {
3418 returnAST = structDeclarator_AST;
3423 )
throws RecognitionException, TokenStreamException {
3426 ASTPair currentAST =
new ASTPair();
3427 TNode enumList_AST =
null;
3431 astFactory.addASTChild(currentAST, returnAST);
3435 if ((LA(1)==
COMMA) && (LA(2)==
ID)) {
3438 astFactory.addASTChild(currentAST, returnAST);
3459 throw new NoViableAltException(
LT(1), getFilename());
3463 enumList_AST = (
TNode)currentAST.root;
3465 catch (RecognitionException ex) {
3466 if (inputState.guessing==0) {
3473 returnAST = enumList_AST;
3478 )
throws RecognitionException, TokenStreamException {
3481 ASTPair currentAST =
new ASTPair();
3482 TNode enumerator_AST =
null;
3488 i_AST = (
TNode)astFactory.create(i);
3489 astFactory.addASTChild(currentAST, i_AST);
3491 if ( inputState.guessing==0 ) {
3493 (
TNode)astFactory.make( (
new ASTArray(3)).add(
null).add((
TNode)astFactory.create(
LITERAL_enum,
"enum")).add((
TNode)astFactory.create(
ID,enumName)))
3501 TNode tmp108_AST =
null;
3502 tmp108_AST = (
TNode)astFactory.create(
LT(1));
3503 astFactory.addASTChild(currentAST, tmp108_AST);
3506 astFactory.addASTChild(currentAST, returnAST);
3516 throw new NoViableAltException(
LT(1), getFilename());
3520 enumerator_AST = (
TNode)currentAST.root;
3522 catch (RecognitionException ex) {
3523 if (inputState.guessing==0) {
3530 returnAST = enumerator_AST;
3534 AST declarationSpecifiers
3535 )
throws RecognitionException, TokenStreamException {
3538 ASTPair currentAST =
new ASTPair();
3539 TNode initDecl_AST =
null;
3541 String declName =
"";
3545 d_AST = (
TNode)returnAST;
3546 astFactory.addASTChild(currentAST, returnAST);
3547 if ( inputState.guessing==0 ) {
3549 ds1 = astFactory.dupList(declarationSpecifiers);
3550 d1 = astFactory.dupList(d_AST);
3551 symbolTable.
add(declName, (
TNode)astFactory.make( (
new ASTArray(3)).add(
null).add(ds1).add(d1)) );
3559 astFactory.addASTChild(currentAST, returnAST);
3571 TNode tmp109_AST =
null;
3572 tmp109_AST = (
TNode)astFactory.create(
LT(1));
3573 astFactory.addASTChild(currentAST, tmp109_AST);
3576 astFactory.addASTChild(currentAST, returnAST);
3581 TNode tmp110_AST =
null;
3582 tmp110_AST = (
TNode)astFactory.create(
LT(1));
3583 astFactory.addASTChild(currentAST, tmp110_AST);
3586 astFactory.addASTChild(currentAST, returnAST);
3596 throw new NoViableAltException(
LT(1), getFilename());
3600 if ( inputState.guessing==0 ) {
3601 initDecl_AST = (
TNode)currentAST.root;
3602 initDecl_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NInitDecl)).add(initDecl_AST));
3603 currentAST.root = initDecl_AST;
3604 currentAST.child = initDecl_AST!=
null &&initDecl_AST.getFirstChild()!=
null ?
3605 initDecl_AST.getFirstChild() : initDecl_AST;
3606 currentAST.advanceChildToEnd();
3608 initDecl_AST = (
TNode)currentAST.root;
3610 catch (RecognitionException ex) {
3611 if (inputState.guessing==0) {
3618 returnAST = initDecl_AST;
3621 public final void attributeList() throws RecognitionException, TokenStreamException {
3624 ASTPair currentAST =
new ASTPair();
3625 TNode attributeList_AST =
null;
3629 astFactory.addASTChild(currentAST, returnAST);
3634 TNode tmp111_AST =
null;
3635 tmp111_AST = (
TNode)astFactory.create(
LT(1));
3636 astFactory.addASTChild(currentAST, tmp111_AST);
3639 astFactory.addASTChild(currentAST, returnAST);
3651 TNode tmp112_AST =
null;
3652 tmp112_AST = (
TNode)astFactory.create(
LT(1));
3653 astFactory.addASTChild(currentAST, tmp112_AST);
3663 throw new NoViableAltException(
LT(1), getFilename());
3667 attributeList_AST = (
TNode)currentAST.root;
3669 catch (RecognitionException ex) {
3670 if (inputState.guessing==0) {
3677 returnAST = attributeList_AST;
3680 protected final void stringConst() throws RecognitionException, TokenStreamException {
3683 ASTPair currentAST =
new ASTPair();
3684 TNode stringConst_AST =
null;
3692 TNode tmp113_AST =
null;
3693 tmp113_AST = (
TNode)astFactory.create(
LT(1));
3694 astFactory.addASTChild(currentAST, tmp113_AST);
3698 if ( _cnt314>=1 ) {
break _loop314; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
3704 if ( inputState.guessing==0 ) {
3705 stringConst_AST = (
TNode)currentAST.root;
3706 stringConst_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NStringSeq)).add(stringConst_AST));
3707 currentAST.root = stringConst_AST;
3708 currentAST.child = stringConst_AST!=
null &&stringConst_AST.getFirstChild()!=
null ?
3709 stringConst_AST.getFirstChild() : stringConst_AST;
3710 currentAST.advanceChildToEnd();
3712 stringConst_AST = (
TNode)currentAST.root;
3714 catch (RecognitionException ex) {
3715 if (inputState.guessing==0) {
3722 returnAST = stringConst_AST;
3725 public final void attribute() throws RecognitionException, TokenStreamException {
3728 ASTPair currentAST =
new ASTPair();
3729 TNode attribute_AST =
null;
3737 TNode tmp114_AST =
null;
3738 tmp114_AST = (
TNode)astFactory.create(
LT(1));
3739 astFactory.addASTChild(currentAST, tmp114_AST);
3743 else if ((LA(1)==
LPAREN)) {
3744 TNode tmp115_AST =
null;
3745 tmp115_AST = (
TNode)astFactory.create(
LT(1));
3746 astFactory.addASTChild(currentAST, tmp115_AST);
3749 astFactory.addASTChild(currentAST, returnAST);
3750 TNode tmp116_AST =
null;
3751 tmp116_AST = (
TNode)astFactory.create(
LT(1));
3752 astFactory.addASTChild(currentAST, tmp116_AST);
3761 attribute_AST = (
TNode)currentAST.root;
3763 catch (RecognitionException ex) {
3764 if (inputState.guessing==0) {
3771 returnAST = attribute_AST;
3776 )
throws RecognitionException, TokenStreamException {
3779 ASTPair currentAST =
new ASTPair();
3780 TNode compoundStatement_AST =
null;
3783 TNode tmp117_AST =
null;
3784 tmp117_AST = (
TNode)astFactory.create(
LT(1));
3785 astFactory.makeASTRoot(currentAST, tmp117_AST);
3787 if ( inputState.guessing==0 ) {
3795 boolean synPredMatched133 =
false;
3798 synPredMatched133 =
true;
3799 inputState.guessing++;
3812 throw new NoViableAltException(
LT(1), getFilename());
3817 catch (RecognitionException pe) {
3818 synPredMatched133 =
false;
3821inputState.guessing--;
3823 if ( synPredMatched133 ) {
3825 astFactory.addASTChild(currentAST, returnAST);
3828 boolean synPredMatched135 =
false;
3831 synPredMatched135 =
true;
3832 inputState.guessing++;
3838 catch (RecognitionException pe) {
3839 synPredMatched135 =
false;
3842inputState.guessing--;
3844 if ( synPredMatched135 ) {
3846 astFactory.addASTChild(currentAST, returnAST);
3890 astFactory.addASTChild(currentAST, returnAST);
3899 throw new NoViableAltException(
LT(1), getFilename());
3903 if ( inputState.guessing==0 ) {
3906 TNode tmp118_AST =
null;
3907 tmp118_AST = (
TNode)astFactory.create(
LT(1));
3908 astFactory.addASTChild(currentAST, tmp118_AST);
3910 if ( inputState.guessing==0 ) {
3911 compoundStatement_AST = (
TNode)currentAST.root;
3914 compoundStatement_AST = (
TNode)currentAST.root;
3916 catch (RecognitionException ex) {
3917 if (inputState.guessing==0) {
3924 returnAST = compoundStatement_AST;
3930 ASTPair currentAST =
new ASTPair();
3931 TNode nestedFunctionDef_AST =
null;
3932 TNode ds_AST =
null;
3941 TNode tmp119_AST =
null;
3942 tmp119_AST = (
TNode)astFactory.create(
LT(1));
3943 astFactory.addASTChild(currentAST, tmp119_AST);
3989 throw new NoViableAltException(
LT(1), getFilename());
3994 boolean synPredMatched142 =
false;
3997 synPredMatched142 =
true;
3998 inputState.guessing++;
4004 catch (RecognitionException pe) {
4005 synPredMatched142 =
false;
4008inputState.guessing--;
4010 if ( synPredMatched142 ) {
4012 ds_AST = (
TNode)returnAST;
4013 astFactory.addASTChild(currentAST, returnAST);
4018 throw new NoViableAltException(
LT(1), getFilename());
4023 d_AST = (
TNode)returnAST;
4024 astFactory.addASTChild(currentAST, returnAST);
4025 if ( inputState.guessing==0 ) {
4028 d2 = astFactory.dupList(d_AST);
4029 ds2 = astFactory.dupList(ds_AST);
4030 symbolTable.
add(declName, (
TNode)astFactory.make( (
new ASTArray(3)).add(
null).add(ds2).add(d2)));
4039 astFactory.addASTChild(currentAST, returnAST);
4047 if ( inputState.guessing==0 ) {
4051 astFactory.addASTChild(currentAST, returnAST);
4052 if ( inputState.guessing==0 ) {
4053 nestedFunctionDef_AST = (
TNode)currentAST.root;
4054 nestedFunctionDef_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NFunctionDef)).add(nestedFunctionDef_AST));
4055 currentAST.root = nestedFunctionDef_AST;
4056 currentAST.child = nestedFunctionDef_AST!=
null &&nestedFunctionDef_AST.getFirstChild()!=
null ?
4057 nestedFunctionDef_AST.getFirstChild() : nestedFunctionDef_AST;
4058 currentAST.advanceChildToEnd();
4060 nestedFunctionDef_AST = (
TNode)currentAST.root;
4062 catch (RecognitionException ex) {
4063 if (inputState.guessing==0) {
4070 returnAST = nestedFunctionDef_AST;
4073 public final void statementList() throws RecognitionException, TokenStreamException {
4076 ASTPair currentAST =
new ASTPair();
4077 TNode statementList_AST =
null;
4086 astFactory.addASTChild(currentAST, returnAST);
4089 if ( _cnt256>=1 ) {
break _loop256; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
4095 statementList_AST = (
TNode)currentAST.root;
4097 catch (RecognitionException ex) {
4098 if (inputState.guessing==0) {
4105 returnAST = statementList_AST;
4108 public final void statement() throws RecognitionException, TokenStreamException {
4111 ASTPair currentAST =
new ASTPair();
4112 TNode statement_AST =
null;
4113 TNode e1_AST =
null;
4114 TNode e2_AST =
null;
4115 TNode e3_AST =
null;
4122 TNode tmp120_AST =
null;
4123 tmp120_AST = (
TNode)astFactory.create(
LT(1));
4124 astFactory.addASTChild(currentAST, tmp120_AST);
4126 statement_AST = (
TNode)currentAST.root;
4132 astFactory.addASTChild(currentAST, returnAST);
4133 statement_AST = (
TNode)currentAST.root;
4138 TNode tmp121_AST =
null;
4139 tmp121_AST = (
TNode)astFactory.create(
LT(1));
4140 astFactory.makeASTRoot(currentAST, tmp121_AST);
4144 astFactory.addASTChild(currentAST, returnAST);
4147 astFactory.addASTChild(currentAST, returnAST);
4148 statement_AST = (
TNode)currentAST.root;
4153 TNode tmp124_AST =
null;
4154 tmp124_AST = (
TNode)astFactory.create(
LT(1));
4155 astFactory.makeASTRoot(currentAST, tmp124_AST);
4158 astFactory.addASTChild(currentAST, returnAST);
4162 astFactory.addASTChild(currentAST, returnAST);
4165 statement_AST = (
TNode)currentAST.root;
4171 TNode tmp130_AST =
null;
4172 tmp130_AST = (
TNode)astFactory.create(
LT(1));
4197 e1_AST = (
TNode)returnAST;
4206 throw new NoViableAltException(
LT(1), getFilename());
4210 TNode tmp131_AST =
null;
4211 tmp131_AST = (
TNode)astFactory.create(
LT(1));
4236 e2_AST = (
TNode)returnAST;
4245 throw new NoViableAltException(
LT(1), getFilename());
4249 TNode tmp132_AST =
null;
4250 tmp132_AST = (
TNode)astFactory.create(
LT(1));
4275 e3_AST = (
TNode)returnAST;
4284 throw new NoViableAltException(
LT(1), getFilename());
4288 TNode tmp133_AST =
null;
4289 tmp133_AST = (
TNode)astFactory.create(
LT(1));
4292 s_AST = (
TNode)returnAST;
4293 if ( inputState.guessing==0 ) {
4294 statement_AST = (
TNode)currentAST.root;
4299 statement_AST = (
TNode)astFactory.make( (
new ASTArray(5)).add((
TNode)astFactory.create(
LITERAL_for,
"for")).add(e1_AST).add(e2_AST).add(e3_AST).add(s_AST));
4301 currentAST.root = statement_AST;
4302 currentAST.child = statement_AST!=
null &&statement_AST.getFirstChild()!=
null ?
4303 statement_AST.getFirstChild() : statement_AST;
4304 currentAST.advanceChildToEnd();
4310 TNode tmp134_AST =
null;
4311 tmp134_AST = (
TNode)astFactory.create(
LT(1));
4312 astFactory.makeASTRoot(currentAST, tmp134_AST);
4315 astFactory.addASTChild(currentAST, returnAST);
4317 statement_AST = (
TNode)currentAST.root;
4322 TNode tmp136_AST =
null;
4323 tmp136_AST = (
TNode)astFactory.create(
LT(1));
4324 astFactory.addASTChild(currentAST, tmp136_AST);
4327 statement_AST = (
TNode)currentAST.root;
4332 TNode tmp138_AST =
null;
4333 tmp138_AST = (
TNode)astFactory.create(
LT(1));
4334 astFactory.addASTChild(currentAST, tmp138_AST);
4337 statement_AST = (
TNode)currentAST.root;
4342 TNode tmp140_AST =
null;
4343 tmp140_AST = (
TNode)astFactory.create(
LT(1));
4344 astFactory.makeASTRoot(currentAST, tmp140_AST);
4369 astFactory.addASTChild(currentAST, returnAST);
4378 throw new NoViableAltException(
LT(1), getFilename());
4383 statement_AST = (
TNode)currentAST.root;
4388 TNode tmp142_AST =
null;
4389 tmp142_AST = (
TNode)astFactory.create(
LT(1));
4390 astFactory.makeASTRoot(currentAST, tmp142_AST);
4393 boolean synPredMatched153 =
false;
4396 synPredMatched153 =
true;
4397 inputState.guessing++;
4404 catch (RecognitionException pe) {
4405 synPredMatched153 =
false;
4408inputState.guessing--;
4410 if ( synPredMatched153 ) {
4412 astFactory.addASTChild(currentAST, returnAST);
4416 astFactory.addASTChild(currentAST, returnAST);
4419 throw new NoViableAltException(
LT(1), getFilename());
4427 astFactory.addASTChild(currentAST, returnAST);
4432 throw new NoViableAltException(
LT(1), getFilename());
4436 statement_AST = (
TNode)currentAST.root;
4441 TNode tmp144_AST =
null;
4442 tmp144_AST = (
TNode)astFactory.create(
LT(1));
4443 astFactory.makeASTRoot(currentAST, tmp144_AST);
4449 astFactory.addASTChild(currentAST, returnAST);
4454 throw new NoViableAltException(
LT(1), getFilename());
4458 statement_AST = (
TNode)currentAST.root;
4463 TNode tmp146_AST =
null;
4464 tmp146_AST = (
TNode)astFactory.create(
LT(1));
4465 astFactory.makeASTRoot(currentAST, tmp146_AST);
4469 astFactory.addASTChild(currentAST, returnAST);
4472 astFactory.addASTChild(currentAST, returnAST);
4475 TNode tmp149_AST =
null;
4476 tmp149_AST = (
TNode)astFactory.create(
LT(1));
4477 astFactory.addASTChild(currentAST, tmp149_AST);
4480 astFactory.addASTChild(currentAST, returnAST);
4485 throw new NoViableAltException(
LT(1), getFilename());
4489 statement_AST = (
TNode)currentAST.root;
4494 TNode tmp150_AST =
null;
4495 tmp150_AST = (
TNode)astFactory.create(
LT(1));
4496 astFactory.makeASTRoot(currentAST, tmp150_AST);
4500 astFactory.addASTChild(currentAST, returnAST);
4503 astFactory.addASTChild(currentAST, returnAST);
4504 statement_AST = (
TNode)currentAST.root;
4510 astFactory.addASTChild(currentAST, returnAST);
4512 if ( inputState.guessing==0 ) {
4513 statement_AST = (
TNode)currentAST.root;
4514 statement_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NStatementExpr)).add(statement_AST));
4515 currentAST.root = statement_AST;
4516 currentAST.child = statement_AST!=
null &&statement_AST.getFirstChild()!=
null ?
4517 statement_AST.getFirstChild() : statement_AST;
4518 currentAST.advanceChildToEnd();
4520 statement_AST = (
TNode)currentAST.root;
4522 else if ((LA(1)==
ID) && (LA(2)==
COLON)) {
4523 TNode tmp154_AST =
null;
4524 tmp154_AST = (
TNode)astFactory.create(
LT(1));
4525 astFactory.addASTChild(currentAST, tmp154_AST);
4531 astFactory.addASTChild(currentAST, returnAST);
4536 throw new NoViableAltException(
LT(1), getFilename());
4540 if ( inputState.guessing==0 ) {
4541 statement_AST = (
TNode)currentAST.root;
4542 statement_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NLabel)).add(statement_AST));
4543 currentAST.root = statement_AST;
4544 currentAST.child = statement_AST!=
null &&statement_AST.getFirstChild()!=
null ?
4545 statement_AST.getFirstChild() : statement_AST;
4546 currentAST.advanceChildToEnd();
4548 statement_AST = (
TNode)currentAST.root;
4551 throw new NoViableAltException(
LT(1), getFilename());
4555 catch (RecognitionException ex) {
4556 if (inputState.guessing==0) {
4563 returnAST = statement_AST;
4569 ASTPair currentAST =
new ASTPair();
4570 TNode conditionalExpr_AST =
null;
4574 astFactory.addASTChild(currentAST, returnAST);
4579 TNode tmp156_AST =
null;
4580 tmp156_AST = (
TNode)astFactory.create(
LT(1));
4581 astFactory.makeASTRoot(currentAST, tmp156_AST);
4606 astFactory.addASTChild(currentAST, returnAST);
4615 throw new NoViableAltException(
LT(1), getFilename());
4619 TNode tmp157_AST =
null;
4620 tmp157_AST = (
TNode)astFactory.create(
LT(1));
4621 astFactory.addASTChild(currentAST, tmp157_AST);
4624 astFactory.addASTChild(currentAST, returnAST);
4652 throw new NoViableAltException(
LT(1), getFilename());
4656 conditionalExpr_AST = (
TNode)currentAST.root;
4658 catch (RecognitionException ex) {
4659 if (inputState.guessing==0) {
4666 returnAST = conditionalExpr_AST;
4669 public final void logicalOrExpr() throws RecognitionException, TokenStreamException {
4672 ASTPair currentAST =
new ASTPair();
4673 TNode logicalOrExpr_AST =
null;
4677 astFactory.addASTChild(currentAST, returnAST);
4682 TNode tmp158_AST =
null;
4683 tmp158_AST = (
TNode)astFactory.create(
LT(1));
4684 astFactory.makeASTRoot(currentAST, tmp158_AST);
4687 astFactory.addASTChild(currentAST, returnAST);
4695 logicalOrExpr_AST = (
TNode)currentAST.root;
4697 catch (RecognitionException ex) {
4698 if (inputState.guessing==0) {
4705 returnAST = logicalOrExpr_AST;
4708 public final void castExpr() throws RecognitionException, TokenStreamException {
4711 ASTPair currentAST =
new ASTPair();
4712 TNode castExpr_AST =
null;
4715 boolean synPredMatched163 =
false;
4718 synPredMatched163 =
true;
4719 inputState.guessing++;
4727 catch (RecognitionException pe) {
4728 synPredMatched163 =
false;
4731inputState.guessing--;
4733 if ( synPredMatched163 ) {
4734 TNode tmp159_AST =
null;
4735 tmp159_AST = (
TNode)astFactory.create(
LT(1));
4736 astFactory.makeASTRoot(currentAST, tmp159_AST);
4739 astFactory.addASTChild(currentAST, returnAST);
4740 TNode tmp160_AST =
null;
4741 tmp160_AST = (
TNode)astFactory.create(
LT(1));
4742 astFactory.addASTChild(currentAST, tmp160_AST);
4767 astFactory.addASTChild(currentAST, returnAST);
4773 astFactory.addASTChild(currentAST, returnAST);
4778 throw new NoViableAltException(
LT(1), getFilename());
4782 if ( inputState.guessing==0 ) {
4783 castExpr_AST = (
TNode)currentAST.root;
4786 castExpr_AST = (
TNode)currentAST.root;
4790 astFactory.addASTChild(currentAST, returnAST);
4791 castExpr_AST = (
TNode)currentAST.root;
4794 throw new NoViableAltException(
LT(1), getFilename());
4798 catch (RecognitionException ex) {
4799 if (inputState.guessing==0) {
4806 returnAST = castExpr_AST;
4809 public final void unaryExpr() throws RecognitionException, TokenStreamException {
4812 ASTPair currentAST =
new ASTPair();
4813 TNode unaryExpr_AST =
null;
4825 astFactory.addASTChild(currentAST, returnAST);
4826 unaryExpr_AST = (
TNode)currentAST.root;
4831 TNode tmp161_AST =
null;
4832 tmp161_AST = (
TNode)astFactory.create(
LT(1));
4833 astFactory.makeASTRoot(currentAST, tmp161_AST);
4836 astFactory.addASTChild(currentAST, returnAST);
4837 unaryExpr_AST = (
TNode)currentAST.root;
4842 TNode tmp162_AST =
null;
4843 tmp162_AST = (
TNode)astFactory.create(
LT(1));
4844 astFactory.makeASTRoot(currentAST, tmp162_AST);
4847 astFactory.addASTChild(currentAST, returnAST);
4848 unaryExpr_AST = (
TNode)currentAST.root;
4862 u_AST = (
TNode)returnAST;
4863 astFactory.addASTChild(currentAST, returnAST);
4865 astFactory.addASTChild(currentAST, returnAST);
4866 if ( inputState.guessing==0 ) {
4867 unaryExpr_AST = (
TNode)currentAST.root;
4868 unaryExpr_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NUnaryExpr)).add(unaryExpr_AST));
4869 currentAST.root = unaryExpr_AST;
4870 currentAST.child = unaryExpr_AST!=
null &&unaryExpr_AST.getFirstChild()!=
null ?
4871 unaryExpr_AST.getFirstChild() : unaryExpr_AST;
4872 currentAST.advanceChildToEnd();
4874 unaryExpr_AST = (
TNode)currentAST.root;
4879 TNode tmp163_AST =
null;
4880 tmp163_AST = (
TNode)astFactory.create(
LT(1));
4881 astFactory.makeASTRoot(currentAST, tmp163_AST);
4884 boolean synPredMatched184 =
false;
4887 synPredMatched184 =
true;
4888 inputState.guessing++;
4895 catch (RecognitionException pe) {
4896 synPredMatched184 =
false;
4899inputState.guessing--;
4901 if ( synPredMatched184 ) {
4902 TNode tmp164_AST =
null;
4903 tmp164_AST = (
TNode)astFactory.create(
LT(1));
4904 astFactory.addASTChild(currentAST, tmp164_AST);
4907 astFactory.addASTChild(currentAST, returnAST);
4908 TNode tmp165_AST =
null;
4909 tmp165_AST = (
TNode)astFactory.create(
LT(1));
4910 astFactory.addASTChild(currentAST, tmp165_AST);
4915 astFactory.addASTChild(currentAST, returnAST);
4918 throw new NoViableAltException(
LT(1), getFilename());
4922 unaryExpr_AST = (
TNode)currentAST.root;
4927 TNode tmp166_AST =
null;
4928 tmp166_AST = (
TNode)astFactory.create(
LT(1));
4929 astFactory.makeASTRoot(currentAST, tmp166_AST);
4932 boolean synPredMatched187 =
false;
4935 synPredMatched187 =
true;
4936 inputState.guessing++;
4943 catch (RecognitionException pe) {
4944 synPredMatched187 =
false;
4947inputState.guessing--;
4949 if ( synPredMatched187 ) {
4950 TNode tmp167_AST =
null;
4951 tmp167_AST = (
TNode)astFactory.create(
LT(1));
4952 astFactory.addASTChild(currentAST, tmp167_AST);
4955 astFactory.addASTChild(currentAST, returnAST);
4956 TNode tmp168_AST =
null;
4957 tmp168_AST = (
TNode)astFactory.create(
LT(1));
4958 astFactory.addASTChild(currentAST, tmp168_AST);
4963 astFactory.addASTChild(currentAST, returnAST);
4966 throw new NoViableAltException(
LT(1), getFilename());
4970 unaryExpr_AST = (
TNode)currentAST.root;
4976 astFactory.addASTChild(currentAST, returnAST);
4977 unaryExpr_AST = (
TNode)currentAST.root;
4982 throw new NoViableAltException(
LT(1), getFilename());
4986 catch (RecognitionException ex) {
4987 if (inputState.guessing==0) {
4994 returnAST = unaryExpr_AST;
5000 ASTPair currentAST =
new ASTPair();
5001 TNode nonemptyAbstractDeclarator_AST =
null;
5009 astFactory.addASTChild(currentAST, returnAST);
5017 TNode tmp169_AST =
null;
5018 tmp169_AST = (
TNode)astFactory.create(
LT(1));
5019 astFactory.addASTChild(currentAST, tmp169_AST);
5028 astFactory.addASTChild(currentAST, returnAST);
5071 astFactory.addASTChild(currentAST, returnAST);
5081 throw new NoViableAltException(
LT(1), getFilename());
5098 throw new NoViableAltException(
LT(1), getFilename());
5102 TNode tmp171_AST =
null;
5103 tmp171_AST = (
TNode)astFactory.create(
LT(1));
5104 astFactory.addASTChild(currentAST, tmp171_AST);
5112 TNode tmp172_AST =
null;
5113 tmp172_AST = (
TNode)astFactory.create(
LT(1));
5114 astFactory.addASTChild(currentAST, tmp172_AST);
5139 astFactory.addASTChild(currentAST, returnAST);
5148 throw new NoViableAltException(
LT(1), getFilename());
5152 TNode tmp173_AST =
null;
5153 tmp173_AST = (
TNode)astFactory.create(
LT(1));
5154 astFactory.addASTChild(currentAST, tmp173_AST);
5179 TNode tmp174_AST =
null;
5180 tmp174_AST = (
TNode)astFactory.create(
LT(1));
5181 astFactory.addASTChild(currentAST, tmp174_AST);
5190 astFactory.addASTChild(currentAST, returnAST);
5233 astFactory.addASTChild(currentAST, returnAST);
5243 throw new NoViableAltException(
LT(1), getFilename());
5260 throw new NoViableAltException(
LT(1), getFilename());
5264 TNode tmp176_AST =
null;
5265 tmp176_AST = (
TNode)astFactory.create(
LT(1));
5266 astFactory.addASTChild(currentAST, tmp176_AST);
5274 TNode tmp177_AST =
null;
5275 tmp177_AST = (
TNode)astFactory.create(
LT(1));
5276 astFactory.addASTChild(currentAST, tmp177_AST);
5301 astFactory.addASTChild(currentAST, returnAST);
5310 throw new NoViableAltException(
LT(1), getFilename());
5314 TNode tmp178_AST =
null;
5315 tmp178_AST = (
TNode)astFactory.create(
LT(1));
5316 astFactory.addASTChild(currentAST, tmp178_AST);
5323 if ( _cnt180>=1 ) {
break _loop180; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
5333 throw new NoViableAltException(
LT(1), getFilename());
5337 if ( inputState.guessing==0 ) {
5338 nonemptyAbstractDeclarator_AST = (
TNode)currentAST.root;
5340 currentAST.root = nonemptyAbstractDeclarator_AST;
5341 currentAST.child = nonemptyAbstractDeclarator_AST!=
null &&nonemptyAbstractDeclarator_AST.getFirstChild()!=
null ?
5342 nonemptyAbstractDeclarator_AST.getFirstChild() : nonemptyAbstractDeclarator_AST;
5343 currentAST.advanceChildToEnd();
5345 nonemptyAbstractDeclarator_AST = (
TNode)currentAST.root;
5347 catch (RecognitionException ex) {
5348 if (inputState.guessing==0) {
5355 returnAST = nonemptyAbstractDeclarator_AST;
5358 public final void postfixExpr() throws RecognitionException, TokenStreamException {
5361 ASTPair currentAST =
new ASTPair();
5362 TNode postfixExpr_AST =
null;
5366 astFactory.addASTChild(currentAST, returnAST);
5377 astFactory.addASTChild(currentAST, returnAST);
5378 if ( inputState.guessing==0 ) {
5379 postfixExpr_AST = (
TNode)currentAST.root;
5380 postfixExpr_AST = (
TNode)astFactory.make( (
new ASTArray(2)).add((
TNode)astFactory.create(
NPostfixExpr)).add(postfixExpr_AST));
5381 currentAST.root = postfixExpr_AST;
5382 currentAST.child = postfixExpr_AST!=
null &&postfixExpr_AST.getFirstChild()!=
null ?
5383 postfixExpr_AST.getFirstChild() : postfixExpr_AST;
5384 currentAST.advanceChildToEnd();
5432 throw new NoViableAltException(
LT(1), getFilename());
5436 postfixExpr_AST = (
TNode)currentAST.root;
5438 catch (RecognitionException ex) {
5439 if (inputState.guessing==0) {
5446 returnAST = postfixExpr_AST;
5449 public final void unaryOperator() throws RecognitionException, TokenStreamException {
5452 ASTPair currentAST =
new ASTPair();
5453 TNode unaryOperator_AST =
null;
5459 TNode tmp179_AST =
null;
5460 tmp179_AST = (
TNode)astFactory.create(
LT(1));
5461 astFactory.addASTChild(currentAST, tmp179_AST);
5463 unaryOperator_AST = (
TNode)currentAST.root;
5468 TNode tmp180_AST =
null;
5469 tmp180_AST = (
TNode)astFactory.create(
LT(1));
5470 astFactory.addASTChild(currentAST, tmp180_AST);
5472 unaryOperator_AST = (
TNode)currentAST.root;
5477 TNode tmp181_AST =
null;
5478 tmp181_AST = (
TNode)astFactory.create(
LT(1));
5479 astFactory.addASTChild(currentAST, tmp181_AST);
5481 unaryOperator_AST = (
TNode)currentAST.root;
5486 TNode tmp182_AST =
null;
5487 tmp182_AST = (
TNode)astFactory.create(
LT(1));
5488 astFactory.addASTChild(currentAST, tmp182_AST);
5490 unaryOperator_AST = (
TNode)currentAST.root;
5495 TNode tmp183_AST =
null;
5496 tmp183_AST = (
TNode)astFactory.create(
LT(1));
5497 astFactory.addASTChild(currentAST, tmp183_AST);
5499 unaryOperator_AST = (
TNode)currentAST.root;
5504 TNode tmp184_AST =
null;
5505 tmp184_AST = (
TNode)astFactory.create(
LT(1));
5506 astFactory.addASTChild(currentAST, tmp184_AST);
5508 unaryOperator_AST = (
TNode)currentAST.root;
5513 TNode tmp185_AST =
null;
5514 tmp185_AST = (
TNode)astFactory.create(
LT(1));
5515 astFactory.addASTChild(currentAST, tmp185_AST);
5517 unaryOperator_AST = (
TNode)currentAST.root;
5522 TNode tmp186_AST =
null;
5523 tmp186_AST = (
TNode)astFactory.create(
LT(1));
5524 astFactory.addASTChild(currentAST, tmp186_AST);
5526 unaryOperator_AST = (
TNode)currentAST.root;
5531 TNode tmp187_AST =
null;
5532 tmp187_AST = (
TNode)astFactory.create(
LT(1));
5533 astFactory.addASTChild(currentAST, tmp187_AST);
5535 unaryOperator_AST = (
TNode)currentAST.root;
5540 throw new NoViableAltException(
LT(1), getFilename());
5544 catch (RecognitionException ex) {
5545 if (inputState.guessing==0) {
5552 returnAST = unaryOperator_AST;
5555 public final void gnuAsmExpr() throws RecognitionException, TokenStreamException {
5558 ASTPair currentAST =
new ASTPair();
5559 TNode gnuAsmExpr_AST =
null;
5562 TNode tmp188_AST =
null;
5563 tmp188_AST = (
TNode)astFactory.create(
LT(1));
5564 astFactory.makeASTRoot(currentAST, tmp188_AST);
5570 TNode tmp189_AST =
null;
5571 tmp189_AST = (
TNode)astFactory.create(
LT(1));
5572 astFactory.addASTChild(currentAST, tmp189_AST);
5582 throw new NoViableAltException(
LT(1), getFilename());
5586 TNode tmp190_AST =
null;
5587 tmp190_AST = (
TNode)astFactory.create(
LT(1));
5588 astFactory.addASTChild(currentAST, tmp190_AST);
5591 astFactory.addASTChild(currentAST, returnAST);
5594 TNode tmp191_AST =
null;
5595 tmp191_AST = (
TNode)astFactory.create(
LT(1));
5596 astFactory.addASTChild(currentAST, tmp191_AST);
5603 astFactory.addASTChild(currentAST, returnAST);
5607 if ((LA(1)==
COMMA)) {
5608 TNode tmp192_AST =
null;
5609 tmp192_AST = (
TNode)astFactory.create(
LT(1));
5610 astFactory.addASTChild(currentAST, tmp192_AST);
5613 astFactory.addASTChild(currentAST, returnAST);
5630 throw new NoViableAltException(
LT(1), getFilename());
5636 TNode tmp193_AST =
null;
5637 tmp193_AST = (
TNode)astFactory.create(
LT(1));
5638 astFactory.addASTChild(currentAST, tmp193_AST);
5645 astFactory.addASTChild(currentAST, returnAST);
5649 if ((LA(1)==
COMMA)) {
5650 TNode tmp194_AST =
null;
5651 tmp194_AST = (
TNode)astFactory.create(
LT(1));
5652 astFactory.addASTChild(currentAST, tmp194_AST);
5655 astFactory.addASTChild(currentAST, returnAST);
5672 throw new NoViableAltException(
LT(1), getFilename());
5680 throw new NoViableAltException(
LT(1), getFilename());
5688 throw new NoViableAltException(
LT(1), getFilename());
5696 TNode tmp195_AST =
null;
5697 tmp195_AST = (
TNode)astFactory.create(
LT(1));
5698 astFactory.addASTChild(currentAST, tmp195_AST);
5701 astFactory.addASTChild(currentAST, returnAST);
5705 if ((LA(1)==
COMMA)) {
5706 TNode tmp196_AST =
null;
5707 tmp196_AST = (
TNode)astFactory.create(
LT(1));
5708 astFactory.addASTChild(currentAST, tmp196_AST);
5711 astFactory.addASTChild(currentAST, returnAST);
5727 throw new NoViableAltException(
LT(1), getFilename());
5731 TNode tmp197_AST =
null;
5732 tmp197_AST = (
TNode)astFactory.create(
LT(1));
5733 astFactory.addASTChild(currentAST, tmp197_AST);
5735 if ( inputState.guessing==0 ) {
5736 gnuAsmExpr_AST = (
TNode)currentAST.root;
5739 gnuAsmExpr_AST = (
TNode)currentAST.root;
5741 catch (RecognitionException ex) {
5742 if (inputState.guessing==0) {
5749 returnAST = gnuAsmExpr_AST;
5752 public final void strOptExprPair() throws RecognitionException, TokenStreamException {
5755 ASTPair currentAST =
new ASTPair();
5756 TNode strOptExprPair_AST =
null;
5760 astFactory.addASTChild(currentAST, returnAST);
5765 TNode tmp198_AST =
null;
5766 tmp198_AST = (
TNode)astFactory.create(
LT(1));
5767 astFactory.addASTChild(currentAST, tmp198_AST);
5770 astFactory.addASTChild(currentAST, returnAST);
5771 TNode tmp199_AST =
null;
5772 tmp199_AST = (
TNode)astFactory.create(
LT(1));
5773 astFactory.addASTChild(currentAST, tmp199_AST);
5785 throw new NoViableAltException(
LT(1), getFilename());
5789 strOptExprPair_AST = (
TNode)currentAST.root;
5791 catch (RecognitionException ex) {
5792 if (inputState.guessing==0) {
5799 returnAST = strOptExprPair_AST;
5802 public final void primaryExpr() throws RecognitionException, TokenStreamException {
5805 ASTPair currentAST =
new ASTPair();
5806 TNode primaryExpr_AST =
null;
5812 TNode tmp200_AST =
null;
5813 tmp200_AST = (
TNode)astFactory.create(
LT(1));
5814 astFactory.addASTChild(currentAST, tmp200_AST);
5816 primaryExpr_AST = (
TNode)currentAST.root;
5821 TNode tmp201_AST =
null;
5822 tmp201_AST = (
TNode)astFactory.create(
LT(1));
5823 astFactory.addASTChild(currentAST, tmp201_AST);
5825 primaryExpr_AST = (
TNode)currentAST.root;
5831 astFactory.addASTChild(currentAST, returnAST);
5832 primaryExpr_AST = (
TNode)currentAST.root;
5838 astFactory.addASTChild(currentAST, returnAST);
5839 primaryExpr_AST = (
TNode)currentAST.root;
5843 boolean synPredMatched206 =
false;
5846 synPredMatched206 =
true;
5847 inputState.guessing++;
5854 catch (RecognitionException pe) {
5855 synPredMatched206 =
false;
5858inputState.guessing--;
5860 if ( synPredMatched206 ) {
5861 TNode tmp202_AST =
null;
5862 tmp202_AST = (
TNode)astFactory.create(
LT(1));
5863 astFactory.makeASTRoot(currentAST, tmp202_AST);
5866 astFactory.addASTChild(currentAST, returnAST);
5867 TNode tmp203_AST =
null;
5868 tmp203_AST = (
TNode)astFactory.create(
LT(1));
5869 astFactory.addASTChild(currentAST, tmp203_AST);
5871 primaryExpr_AST = (
TNode)currentAST.root;
5874 TNode tmp204_AST =
null;
5875 tmp204_AST = (
TNode)astFactory.create(
LT(1));
5876 astFactory.makeASTRoot(currentAST, tmp204_AST);
5879 astFactory.addASTChild(currentAST, returnAST);
5880 TNode tmp205_AST =
null;
5881 tmp205_AST = (
TNode)astFactory.create(
LT(1));
5882 astFactory.addASTChild(currentAST, tmp205_AST);
5884 if ( inputState.guessing==0 ) {
5885 primaryExpr_AST = (
TNode)currentAST.root;
5888 primaryExpr_AST = (
TNode)currentAST.root;
5891 throw new NoViableAltException(
LT(1), getFilename());
5895 catch (RecognitionException ex) {
5896 if (inputState.guessing==0) {
5903 returnAST = primaryExpr_AST;
5906 protected final void charConst() throws RecognitionException, TokenStreamException {
5909 ASTPair currentAST =
new ASTPair();
5910 TNode charConst_AST =
null;
5913 TNode tmp206_AST =
null;
5914 tmp206_AST = (
TNode)astFactory.create(
LT(1));
5915 astFactory.addASTChild(currentAST, tmp206_AST);
5917 charConst_AST = (
TNode)currentAST.root;
5919 catch (RecognitionException ex) {
5920 if (inputState.guessing==0) {
5927 returnAST = charConst_AST;
5933 ASTPair currentAST =
new ASTPair();
5934 TNode storageClassSpecifier_AST =
null;
5940 TNode tmp207_AST =
null;
5941 tmp207_AST = (
TNode)astFactory.create(
LT(1));
5942 astFactory.addASTChild(currentAST, tmp207_AST);
5944 storageClassSpecifier_AST = (
TNode)currentAST.root;
5949 TNode tmp208_AST =
null;
5950 tmp208_AST = (
TNode)astFactory.create(
LT(1));
5951 astFactory.addASTChild(currentAST, tmp208_AST);
5953 storageClassSpecifier_AST = (
TNode)currentAST.root;
5958 TNode tmp209_AST =
null;
5959 tmp209_AST = (
TNode)astFactory.create(
LT(1));
5960 astFactory.addASTChild(currentAST, tmp209_AST);
5962 storageClassSpecifier_AST = (
TNode)currentAST.root;
5970 astFactory.addASTChild(currentAST, returnAST);
5971 storageClassSpecifier_AST = (
TNode)currentAST.root;
5976 throw new NoViableAltException(
LT(1), getFilename());
5980 catch (RecognitionException ex) {
5981 if (inputState.guessing==0) {
5988 returnAST = storageClassSpecifier_AST;
5991 public final void typeQualifier() throws RecognitionException, TokenStreamException {
5994 ASTPair currentAST =
new ASTPair();
5995 TNode typeQualifier_AST =
null;
6001 TNode tmp210_AST =
null;
6002 tmp210_AST = (
TNode)astFactory.create(
LT(1));
6003 astFactory.addASTChild(currentAST, tmp210_AST);
6005 typeQualifier_AST = (
TNode)currentAST.root;
6010 TNode tmp211_AST =
null;
6011 tmp211_AST = (
TNode)astFactory.create(
LT(1));
6012 astFactory.addASTChild(currentAST, tmp211_AST);
6014 typeQualifier_AST = (
TNode)currentAST.root;
6019 throw new NoViableAltException(
LT(1), getFilename());
6023 catch (RecognitionException ex) {
6024 if (inputState.guessing==0) {
6031 returnAST = typeQualifier_AST;
6034 public final void assignOperator() throws RecognitionException, TokenStreamException {
6037 ASTPair currentAST =
new ASTPair();
6038 TNode assignOperator_AST =
null;
6044 TNode tmp212_AST =
null;
6045 tmp212_AST = (
TNode)astFactory.create(
LT(1));
6046 astFactory.addASTChild(currentAST, tmp212_AST);
6048 assignOperator_AST = (
TNode)currentAST.root;
6053 TNode tmp213_AST =
null;
6054 tmp213_AST = (
TNode)astFactory.create(
LT(1));
6055 astFactory.addASTChild(currentAST, tmp213_AST);
6057 assignOperator_AST = (
TNode)currentAST.root;
6062 TNode tmp214_AST =
null;
6063 tmp214_AST = (
TNode)astFactory.create(
LT(1));
6064 astFactory.addASTChild(currentAST, tmp214_AST);
6066 assignOperator_AST = (
TNode)currentAST.root;
6071 TNode tmp215_AST =
null;
6072 tmp215_AST = (
TNode)astFactory.create(
LT(1));
6073 astFactory.addASTChild(currentAST, tmp215_AST);
6075 assignOperator_AST = (
TNode)currentAST.root;
6080 TNode tmp216_AST =
null;
6081 tmp216_AST = (
TNode)astFactory.create(
LT(1));
6082 astFactory.addASTChild(currentAST, tmp216_AST);
6084 assignOperator_AST = (
TNode)currentAST.root;
6089 TNode tmp217_AST =
null;
6090 tmp217_AST = (
TNode)astFactory.create(
LT(1));
6091 astFactory.addASTChild(currentAST, tmp217_AST);
6093 assignOperator_AST = (
TNode)currentAST.root;
6098 TNode tmp218_AST =
null;
6099 tmp218_AST = (
TNode)astFactory.create(
LT(1));
6100 astFactory.addASTChild(currentAST, tmp218_AST);
6102 assignOperator_AST = (
TNode)currentAST.root;
6107 TNode tmp219_AST =
null;
6108 tmp219_AST = (
TNode)astFactory.create(
LT(1));
6109 astFactory.addASTChild(currentAST, tmp219_AST);
6111 assignOperator_AST = (
TNode)currentAST.root;
6116 TNode tmp220_AST =
null;
6117 tmp220_AST = (
TNode)astFactory.create(
LT(1));
6118 astFactory.addASTChild(currentAST, tmp220_AST);
6120 assignOperator_AST = (
TNode)currentAST.root;
6125 TNode tmp221_AST =
null;
6126 tmp221_AST = (
TNode)astFactory.create(
LT(1));
6127 astFactory.addASTChild(currentAST, tmp221_AST);
6129 assignOperator_AST = (
TNode)currentAST.root;
6134 TNode tmp222_AST =
null;
6135 tmp222_AST = (
TNode)astFactory.create(
LT(1));
6136 astFactory.addASTChild(currentAST, tmp222_AST);
6138 assignOperator_AST = (
TNode)currentAST.root;
6143 throw new NoViableAltException(
LT(1), getFilename());
6147 catch (RecognitionException ex) {
6148 if (inputState.guessing==0) {
6155 returnAST = assignOperator_AST;
6158 public final void logicalAndExpr() throws RecognitionException, TokenStreamException {
6161 ASTPair currentAST =
new ASTPair();
6162 TNode logicalAndExpr_AST =
null;
6166 astFactory.addASTChild(currentAST, returnAST);
6170 if ((LA(1)==
LAND)) {
6171 TNode tmp223_AST =
null;
6172 tmp223_AST = (
TNode)astFactory.create(
LT(1));
6173 astFactory.makeASTRoot(currentAST, tmp223_AST);
6176 astFactory.addASTChild(currentAST, returnAST);
6184 logicalAndExpr_AST = (
TNode)currentAST.root;
6186 catch (RecognitionException ex) {
6187 if (inputState.guessing==0) {
6194 returnAST = logicalAndExpr_AST;
6200 ASTPair currentAST =
new ASTPair();
6201 TNode inclusiveOrExpr_AST =
null;
6205 astFactory.addASTChild(currentAST, returnAST);
6210 TNode tmp224_AST =
null;
6211 tmp224_AST = (
TNode)astFactory.create(
LT(1));
6212 astFactory.makeASTRoot(currentAST, tmp224_AST);
6215 astFactory.addASTChild(currentAST, returnAST);
6223 inclusiveOrExpr_AST = (
TNode)currentAST.root;
6225 catch (RecognitionException ex) {
6226 if (inputState.guessing==0) {
6233 returnAST = inclusiveOrExpr_AST;
6239 ASTPair currentAST =
new ASTPair();
6240 TNode exclusiveOrExpr_AST =
null;
6244 astFactory.addASTChild(currentAST, returnAST);
6248 if ((LA(1)==
BXOR)) {
6249 TNode tmp225_AST =
null;
6250 tmp225_AST = (
TNode)astFactory.create(
LT(1));
6251 astFactory.makeASTRoot(currentAST, tmp225_AST);
6254 astFactory.addASTChild(currentAST, returnAST);
6262 exclusiveOrExpr_AST = (
TNode)currentAST.root;
6264 catch (RecognitionException ex) {
6265 if (inputState.guessing==0) {
6272 returnAST = exclusiveOrExpr_AST;
6275 public final void bitAndExpr() throws RecognitionException, TokenStreamException {
6278 ASTPair currentAST =
new ASTPair();
6279 TNode bitAndExpr_AST =
null;
6283 astFactory.addASTChild(currentAST, returnAST);
6287 if ((LA(1)==
BAND)) {
6288 TNode tmp226_AST =
null;
6289 tmp226_AST = (
TNode)astFactory.create(
LT(1));
6290 astFactory.makeASTRoot(currentAST, tmp226_AST);
6293 astFactory.addASTChild(currentAST, returnAST);
6301 bitAndExpr_AST = (
TNode)currentAST.root;
6303 catch (RecognitionException ex) {
6304 if (inputState.guessing==0) {
6311 returnAST = bitAndExpr_AST;
6314 public final void equalityExpr() throws RecognitionException, TokenStreamException {
6317 ASTPair currentAST =
new ASTPair();
6318 TNode equalityExpr_AST =
null;
6322 astFactory.addASTChild(currentAST, returnAST);
6331 TNode tmp227_AST =
null;
6332 tmp227_AST = (
TNode)astFactory.create(
LT(1));
6333 astFactory.makeASTRoot(currentAST, tmp227_AST);
6339 TNode tmp228_AST =
null;
6340 tmp228_AST = (
TNode)astFactory.create(
LT(1));
6341 astFactory.makeASTRoot(currentAST, tmp228_AST);
6347 throw new NoViableAltException(
LT(1), getFilename());
6352 astFactory.addASTChild(currentAST, returnAST);
6360 equalityExpr_AST = (
TNode)currentAST.root;
6362 catch (RecognitionException ex) {
6363 if (inputState.guessing==0) {
6370 returnAST = equalityExpr_AST;
6373 public final void relationalExpr() throws RecognitionException, TokenStreamException {
6376 ASTPair currentAST =
new ASTPair();
6377 TNode relationalExpr_AST =
null;
6381 astFactory.addASTChild(currentAST, returnAST);
6385 if (((LA(1) >=
LT && LA(1) <=
GTE))) {
6390 TNode tmp229_AST =
null;
6391 tmp229_AST = (
TNode)astFactory.create(
LT(1));
6392 astFactory.makeASTRoot(currentAST, tmp229_AST);
6398 TNode tmp230_AST =
null;
6399 tmp230_AST = (
TNode)astFactory.create(
LT(1));
6400 astFactory.makeASTRoot(currentAST, tmp230_AST);
6406 TNode tmp231_AST =
null;
6407 tmp231_AST = (
TNode)astFactory.create(
LT(1));
6408 astFactory.makeASTRoot(currentAST, tmp231_AST);
6414 TNode tmp232_AST =
null;
6415 tmp232_AST = (
TNode)astFactory.create(
LT(1));
6416 astFactory.makeASTRoot(currentAST, tmp232_AST);
6422 throw new NoViableAltException(
LT(1), getFilename());
6427 astFactory.addASTChild(currentAST, returnAST);
6435 relationalExpr_AST = (
TNode)currentAST.root;
6437 catch (RecognitionException ex) {
6438 if (inputState.guessing==0) {
6445 returnAST = relationalExpr_AST;
6448 public final void shiftExpr() throws RecognitionException, TokenStreamException {
6451 ASTPair currentAST =
new ASTPair();
6452 TNode shiftExpr_AST =
null;
6456 astFactory.addASTChild(currentAST, returnAST);
6465 TNode tmp233_AST =
null;
6466 tmp233_AST = (
TNode)astFactory.create(
LT(1));
6467 astFactory.makeASTRoot(currentAST, tmp233_AST);
6473 TNode tmp234_AST =
null;
6474 tmp234_AST = (
TNode)astFactory.create(
LT(1));
6475 astFactory.makeASTRoot(currentAST, tmp234_AST);
6481 throw new NoViableAltException(
LT(1), getFilename());
6486 astFactory.addASTChild(currentAST, returnAST);
6494 shiftExpr_AST = (
TNode)currentAST.root;
6496 catch (RecognitionException ex) {
6497 if (inputState.guessing==0) {
6504 returnAST = shiftExpr_AST;
6507 public final void additiveExpr() throws RecognitionException, TokenStreamException {
6510 ASTPair currentAST =
new ASTPair();
6511 TNode additiveExpr_AST =
null;
6515 astFactory.addASTChild(currentAST, returnAST);
6524 TNode tmp235_AST =
null;
6525 tmp235_AST = (
TNode)astFactory.create(
LT(1));
6526 astFactory.makeASTRoot(currentAST, tmp235_AST);
6532 TNode tmp236_AST =
null;
6533 tmp236_AST = (
TNode)astFactory.create(
LT(1));
6534 astFactory.makeASTRoot(currentAST, tmp236_AST);
6540 throw new NoViableAltException(
LT(1), getFilename());
6545 astFactory.addASTChild(currentAST, returnAST);
6553 additiveExpr_AST = (
TNode)currentAST.root;
6555 catch (RecognitionException ex) {
6556 if (inputState.guessing==0) {
6563 returnAST = additiveExpr_AST;
6566 public final void multExpr() throws RecognitionException, TokenStreamException {
6569 ASTPair currentAST =
new ASTPair();
6570 TNode multExpr_AST =
null;
6574 astFactory.addASTChild(currentAST, returnAST);
6583 TNode tmp237_AST =
null;
6584 tmp237_AST = (
TNode)astFactory.create(
LT(1));
6585 astFactory.makeASTRoot(currentAST, tmp237_AST);
6591 TNode tmp238_AST =
null;
6592 tmp238_AST = (
TNode)astFactory.create(
LT(1));
6593 astFactory.makeASTRoot(currentAST, tmp238_AST);
6599 TNode tmp239_AST =
null;
6600 tmp239_AST = (
TNode)astFactory.create(
LT(1));
6601 astFactory.makeASTRoot(currentAST, tmp239_AST);
6607 throw new NoViableAltException(
LT(1), getFilename());
6612 astFactory.addASTChild(currentAST, returnAST);
6620 multExpr_AST = (
TNode)currentAST.root;
6622 catch (RecognitionException ex) {
6623 if (inputState.guessing==0) {
6630 returnAST = multExpr_AST;
6633 public final void postfixSuffix() throws RecognitionException, TokenStreamException {
6636 ASTPair currentAST =
new ASTPair();
6637 TNode postfixSuffix_AST =
null;
6647 TNode tmp240_AST =
null;
6648 tmp240_AST = (
TNode)astFactory.create(
LT(1));
6649 astFactory.addASTChild(currentAST, tmp240_AST);
6651 TNode tmp241_AST =
null;
6652 tmp241_AST = (
TNode)astFactory.create(
LT(1));
6653 astFactory.addASTChild(currentAST, tmp241_AST);
6659 TNode tmp242_AST =
null;
6660 tmp242_AST = (
TNode)astFactory.create(
LT(1));
6661 astFactory.addASTChild(currentAST, tmp242_AST);
6663 TNode tmp243_AST =
null;
6664 tmp243_AST = (
TNode)astFactory.create(
LT(1));
6665 astFactory.addASTChild(currentAST, tmp243_AST);
6672 astFactory.addASTChild(currentAST, returnAST);
6677 TNode tmp244_AST =
null;
6678 tmp244_AST = (
TNode)astFactory.create(
LT(1));
6679 astFactory.addASTChild(currentAST, tmp244_AST);
6682 astFactory.addASTChild(currentAST, returnAST);
6683 TNode tmp245_AST =
null;
6684 tmp245_AST = (
TNode)astFactory.create(
LT(1));
6685 astFactory.addASTChild(currentAST, tmp245_AST);
6691 TNode tmp246_AST =
null;
6692 tmp246_AST = (
TNode)astFactory.create(
LT(1));
6693 astFactory.addASTChild(currentAST, tmp246_AST);
6699 TNode tmp247_AST =
null;
6700 tmp247_AST = (
TNode)astFactory.create(
LT(1));
6701 astFactory.addASTChild(currentAST, tmp247_AST);
6707 if ( _cnt305>=1 ) {
break _loop305; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
6713 postfixSuffix_AST = (
TNode)currentAST.root;
6715 catch (RecognitionException ex) {
6716 if (inputState.guessing==0) {
6723 returnAST = postfixSuffix_AST;
6726 public final void functionCall() throws RecognitionException, TokenStreamException {
6729 ASTPair currentAST =
new ASTPair();
6730 TNode functionCall_AST =
null;
6734 TNode tmp248_AST =
null;
6735 tmp248_AST = (
TNode)astFactory.create(
LT(1));
6736 astFactory.makeASTRoot(currentAST, tmp248_AST);
6761 a_AST = (
TNode)returnAST;
6762 astFactory.addASTChild(currentAST, returnAST);
6771 throw new NoViableAltException(
LT(1), getFilename());
6775 TNode tmp249_AST =
null;
6776 tmp249_AST = (
TNode)astFactory.create(
LT(1));
6777 astFactory.addASTChild(currentAST, tmp249_AST);
6779 if ( inputState.guessing==0 ) {
6780 functionCall_AST = (
TNode)currentAST.root;
6785 functionCall_AST = (
TNode)currentAST.root;
6787 catch (RecognitionException ex) {
6788 if (inputState.guessing==0) {
6795 returnAST = functionCall_AST;
6798 public final void argExprList() throws RecognitionException, TokenStreamException {
6801 ASTPair currentAST =
new ASTPair();
6802 TNode argExprList_AST =
null;
6806 astFactory.addASTChild(currentAST, returnAST);
6810 if ((LA(1)==
COMMA)) {
6813 astFactory.addASTChild(currentAST, returnAST);
6821 argExprList_AST = (
TNode)currentAST.root;
6823 catch (RecognitionException ex) {
6824 if (inputState.guessing==0) {
6831 returnAST = argExprList_AST;
6834 protected final void intConst() throws RecognitionException, TokenStreamException {
6837 ASTPair currentAST =
new ASTPair();
6838 TNode intConst_AST =
null;
6844 TNode tmp251_AST =
null;
6845 tmp251_AST = (
TNode)astFactory.create(
LT(1));
6846 astFactory.addASTChild(currentAST, tmp251_AST);
6848 intConst_AST = (
TNode)currentAST.root;
6853 TNode tmp252_AST =
null;
6854 tmp252_AST = (
TNode)astFactory.create(
LT(1));
6855 astFactory.addASTChild(currentAST, tmp252_AST);
6857 intConst_AST = (
TNode)currentAST.root;
6862 TNode tmp253_AST =
null;
6863 tmp253_AST = (
TNode)astFactory.create(
LT(1));
6864 astFactory.addASTChild(currentAST, tmp253_AST);
6866 intConst_AST = (
TNode)currentAST.root;
6871 TNode tmp254_AST =
null;
6872 tmp254_AST = (
TNode)astFactory.create(
LT(1));
6873 astFactory.addASTChild(currentAST, tmp254_AST);
6875 intConst_AST = (
TNode)currentAST.root;
6880 TNode tmp255_AST =
null;
6881 tmp255_AST = (
TNode)astFactory.create(
LT(1));
6882 astFactory.addASTChild(currentAST, tmp255_AST);
6884 intConst_AST = (
TNode)currentAST.root;
6889 TNode tmp256_AST =
null;
6890 tmp256_AST = (
TNode)astFactory.create(
LT(1));
6891 astFactory.addASTChild(currentAST, tmp256_AST);
6893 intConst_AST = (
TNode)currentAST.root;
6898 TNode tmp257_AST =
null;
6899 tmp257_AST = (
TNode)astFactory.create(
LT(1));
6900 astFactory.addASTChild(currentAST, tmp257_AST);
6902 intConst_AST = (
TNode)currentAST.root;
6907 TNode tmp258_AST =
null;
6908 tmp258_AST = (
TNode)astFactory.create(
LT(1));
6909 astFactory.addASTChild(currentAST, tmp258_AST);
6911 intConst_AST = (
TNode)currentAST.root;
6916 TNode tmp259_AST =
null;
6917 tmp259_AST = (
TNode)astFactory.create(
LT(1));
6918 astFactory.addASTChild(currentAST, tmp259_AST);
6920 intConst_AST = (
TNode)currentAST.root;
6925 throw new NoViableAltException(
LT(1), getFilename());
6929 catch (RecognitionException ex) {
6930 if (inputState.guessing==0) {
6937 returnAST = intConst_AST;
6940 protected final void floatConst() throws RecognitionException, TokenStreamException {
6943 ASTPair currentAST =
new ASTPair();
6944 TNode floatConst_AST =
null;
6950 TNode tmp260_AST =
null;
6951 tmp260_AST = (
TNode)astFactory.create(
LT(1));
6952 astFactory.addASTChild(currentAST, tmp260_AST);
6954 floatConst_AST = (
TNode)currentAST.root;
6959 TNode tmp261_AST =
null;
6960 tmp261_AST = (
TNode)astFactory.create(
LT(1));
6961 astFactory.addASTChild(currentAST, tmp261_AST);
6963 floatConst_AST = (
TNode)currentAST.root;
6968 TNode tmp262_AST =
null;
6969 tmp262_AST = (
TNode)astFactory.create(
LT(1));
6970 astFactory.addASTChild(currentAST, tmp262_AST);
6972 floatConst_AST = (
TNode)currentAST.root;
6977 throw new NoViableAltException(
LT(1), getFilename());
6981 catch (RecognitionException ex) {
6982 if (inputState.guessing==0) {
6989 returnAST = floatConst_AST;
6992 public final void dummy() throws RecognitionException, TokenStreamException {
6995 ASTPair currentAST =
new ASTPair();
6996 TNode dummy_AST =
null;
7002 TNode tmp263_AST =
null;
7003 tmp263_AST = (
TNode)astFactory.create(
LT(1));
7004 astFactory.addASTChild(currentAST, tmp263_AST);
7006 dummy_AST = (
TNode)currentAST.root;
7011 TNode tmp264_AST =
null;
7012 tmp264_AST = (
TNode)astFactory.create(
LT(1));
7013 astFactory.addASTChild(currentAST, tmp264_AST);
7015 dummy_AST = (
TNode)currentAST.root;
7020 TNode tmp265_AST =
null;
7021 tmp265_AST = (
TNode)astFactory.create(
LT(1));
7022 astFactory.addASTChild(currentAST, tmp265_AST);
7024 dummy_AST = (
TNode)currentAST.root;
7029 TNode tmp266_AST =
null;
7030 tmp266_AST = (
TNode)astFactory.create(
LT(1));
7031 astFactory.addASTChild(currentAST, tmp266_AST);
7033 dummy_AST = (
TNode)currentAST.root;
7038 TNode tmp267_AST =
null;
7039 tmp267_AST = (
TNode)astFactory.create(
LT(1));
7040 astFactory.addASTChild(currentAST, tmp267_AST);
7042 dummy_AST = (
TNode)currentAST.root;
7047 TNode tmp268_AST =
null;
7048 tmp268_AST = (
TNode)astFactory.create(
LT(1));
7049 astFactory.addASTChild(currentAST, tmp268_AST);
7051 dummy_AST = (
TNode)currentAST.root;
7056 TNode tmp269_AST =
null;
7057 tmp269_AST = (
TNode)astFactory.create(
LT(1));
7058 astFactory.addASTChild(currentAST, tmp269_AST);
7060 dummy_AST = (
TNode)currentAST.root;
7065 TNode tmp270_AST =
null;
7066 tmp270_AST = (
TNode)astFactory.create(
LT(1));
7067 astFactory.addASTChild(currentAST, tmp270_AST);
7069 dummy_AST = (
TNode)currentAST.root;
7074 TNode tmp271_AST =
null;
7075 tmp271_AST = (
TNode)astFactory.create(
LT(1));
7076 astFactory.addASTChild(currentAST, tmp271_AST);
7078 dummy_AST = (
TNode)currentAST.root;
7083 TNode tmp272_AST =
null;
7084 tmp272_AST = (
TNode)astFactory.create(
LT(1));
7085 astFactory.addASTChild(currentAST, tmp272_AST);
7087 dummy_AST = (
TNode)currentAST.root;
7092 TNode tmp273_AST =
null;
7093 tmp273_AST = (
TNode)astFactory.create(
LT(1));
7094 astFactory.addASTChild(currentAST, tmp273_AST);
7096 dummy_AST = (
TNode)currentAST.root;
7101 TNode tmp274_AST =
null;
7102 tmp274_AST = (
TNode)astFactory.create(
LT(1));
7103 astFactory.addASTChild(currentAST, tmp274_AST);
7105 dummy_AST = (
TNode)currentAST.root;
7110 TNode tmp275_AST =
null;
7111 tmp275_AST = (
TNode)astFactory.create(
LT(1));
7112 astFactory.addASTChild(currentAST, tmp275_AST);
7114 dummy_AST = (
TNode)currentAST.root;
7119 TNode tmp276_AST =
null;
7120 tmp276_AST = (
TNode)astFactory.create(
LT(1));
7121 astFactory.addASTChild(currentAST, tmp276_AST);
7123 dummy_AST = (
TNode)currentAST.root;
7128 TNode tmp277_AST =
null;
7129 tmp277_AST = (
TNode)astFactory.create(
LT(1));
7130 astFactory.addASTChild(currentAST, tmp277_AST);
7132 dummy_AST = (
TNode)currentAST.root;
7137 TNode tmp278_AST =
null;
7138 tmp278_AST = (
TNode)astFactory.create(
LT(1));
7139 astFactory.addASTChild(currentAST, tmp278_AST);
7141 dummy_AST = (
TNode)currentAST.root;
7146 TNode tmp279_AST =
null;
7147 tmp279_AST = (
TNode)astFactory.create(
LT(1));
7148 astFactory.addASTChild(currentAST, tmp279_AST);
7150 dummy_AST = (
TNode)currentAST.root;
7155 TNode tmp280_AST =
null;
7156 tmp280_AST = (
TNode)astFactory.create(
LT(1));
7157 astFactory.addASTChild(currentAST, tmp280_AST);
7159 dummy_AST = (
TNode)currentAST.root;
7164 TNode tmp281_AST =
null;
7165 tmp281_AST = (
TNode)astFactory.create(
LT(1));
7166 astFactory.addASTChild(currentAST, tmp281_AST);
7168 dummy_AST = (
TNode)currentAST.root;
7173 TNode tmp282_AST =
null;
7174 tmp282_AST = (
TNode)astFactory.create(
LT(1));
7175 astFactory.addASTChild(currentAST, tmp282_AST);
7177 dummy_AST = (
TNode)currentAST.root;
7182 TNode tmp283_AST =
null;
7183 tmp283_AST = (
TNode)astFactory.create(
LT(1));
7184 astFactory.addASTChild(currentAST, tmp283_AST);
7186 dummy_AST = (
TNode)currentAST.root;
7191 TNode tmp284_AST =
null;
7192 tmp284_AST = (
TNode)astFactory.create(
LT(1));
7193 astFactory.addASTChild(currentAST, tmp284_AST);
7195 dummy_AST = (
TNode)currentAST.root;
7200 TNode tmp285_AST =
null;
7201 tmp285_AST = (
TNode)astFactory.create(
LT(1));
7202 astFactory.addASTChild(currentAST, tmp285_AST);
7204 dummy_AST = (
TNode)currentAST.root;
7209 TNode tmp286_AST =
null;
7210 tmp286_AST = (
TNode)astFactory.create(
LT(1));
7211 astFactory.addASTChild(currentAST, tmp286_AST);
7213 dummy_AST = (
TNode)currentAST.root;
7218 TNode tmp287_AST =
null;
7219 tmp287_AST = (
TNode)astFactory.create(
LT(1));
7220 astFactory.addASTChild(currentAST, tmp287_AST);
7222 dummy_AST = (
TNode)currentAST.root;
7227 TNode tmp288_AST =
null;
7228 tmp288_AST = (
TNode)astFactory.create(
LT(1));
7229 astFactory.addASTChild(currentAST, tmp288_AST);
7231 dummy_AST = (
TNode)currentAST.root;
7236 TNode tmp289_AST =
null;
7237 tmp289_AST = (
TNode)astFactory.create(
LT(1));
7238 astFactory.addASTChild(currentAST, tmp289_AST);
7240 dummy_AST = (
TNode)currentAST.root;
7245 TNode tmp290_AST =
null;
7246 tmp290_AST = (
TNode)astFactory.create(
LT(1));
7247 astFactory.addASTChild(currentAST, tmp290_AST);
7249 dummy_AST = (
TNode)currentAST.root;
7254 throw new NoViableAltException(
LT(1), getFilename());
7258 catch (RecognitionException ex) {
7259 if (inputState.guessing==0) {
7266 returnAST = dummy_AST;
7274 "NULL_TREE_LOOKAHEAD",
7374 "UnsignedOctalConst",
7382 "DoubleDoubleConst",
7387 "NStructDeclarator",
7392 "NFunctionCallArgs",
7393 "NNonemptyAbstractDeclarator",
7397 "NParameterTypeList",
7399 "NCompoundStatement",
7400 "NParameterDeclaration",
7407 "NInitializerElementLabel",
7408 "NLcurlyInitializer",
7441 tokenTypeToASTClassMap=
null;
7444 private static final long[] mk_tokenSet_0() {
7445 long[] data = { 2L, 0L, 0L};
7449 private static final long[] mk_tokenSet_1() {
7450 long[] data = { 219902325554800L, 0L, 30064771072L, 0L, 0L, 0L};
7454 private static final long[] mk_tokenSet_2() {
7455 long[] data = { 219902325554802L, 0L, 30064771072L, 0L, 0L, 0L};
7459 private static final long[] mk_tokenSet_3() {
7460 long[] data = { 215504279044128L, 111451082752L, 482110078976L, 0L, 0L, 0L};
7464 private static final long[] mk_tokenSet_4() {
7465 long[] data = { 1433763162620672L, 0L, 0L};
7469 private static final long[] mk_tokenSet_5() {
7470 long[] data = { 290271069732864L, 0L, 0L};
7474 private static final long[] mk_tokenSet_6() {
7475 long[] data = { 8796093021264L, 0L, 30064771072L, 0L, 0L, 0L};
7479 private static final long[] mk_tokenSet_7() {
7480 long[] data = { 219902325554896L, 0L, 30064771072L, 0L, 0L, 0L};
7484 private static final long[] mk_tokenSet_8() {
7485 long[] data = { 219902325529664L, 0L, 30064771072L, 0L, 0L, 0L};
7489 private static final long[] mk_tokenSet_9() {
7490 long[] data = { 3034652092661456L, 0L, 30064771072L, 0L, 0L, 0L};
7494 private static final long[] mk_tokenSet_10() {
7495 long[] data = { 215504279044096L, 0L, 0L};
7499 private static final long[] mk_tokenSet_11() {
7500 long[] data = { 840026883752544L, 0L, 34359738368L, 0L, 0L, 0L};
7504 private static final long[] mk_tokenSet_12() {
7505 long[] data = { -4613717915915517966L, 111451082752L, 514322333696L, 0L, 0L, 0L};
7509 private static final long[] mk_tokenSet_13() {
7510 long[] data = { 8796092996672L, 0L, 30064771072L, 0L, 0L, 0L};
7514 private static final long[] mk_tokenSet_14() {
7515 long[] data = { 219902325529792L, 0L, 30064771072L, 0L, 0L, 0L};
7519 private static final long[] mk_tokenSet_15() {
7520 long[] data = { 8796092767232L, 0L, 25769803776L, 0L, 0L, 0L};
7524 private static final long[] mk_tokenSet_16() {
7525 long[] data = { 2603643534573296L, 0L, 64424509440L, 0L, 0L, 0L};
7529 private static final long[] mk_tokenSet_17() {
7530 long[] data = { 512L, 0L, 0L};
7534 private static final long[] mk_tokenSet_18() {
7535 long[] data = { 778454232465568L, 128630951936L, 482110078976L, 0L, 0L, 0L};
7539 private static final long[] mk_tokenSet_19() {
7540 long[] data = { 844424930009056L, 137438953471L, 507879882752L, 0L, 0L, 0L};
7544 private static final long[] mk_tokenSet_20() {
7545 long[] data = { 567347999932416L, 17179869184L, 0L, 0L};
7549 private static final long[] mk_tokenSet_21() {
7550 long[] data = { 233096465088544L, 111451082752L, 482110078976L, 0L, 0L, 0L};
7554 private static final long[] mk_tokenSet_22() {
7555 long[] data = { 215504279044256L, 111451082752L, 482110078976L, 0L, 0L, 0L};
7559 private static final long[] mk_tokenSet_23() {
7560 long[] data = { 826832743964640L, 137438953471L, 507879882752L, 0L, 0L, 0L};
7564 private static final long[] mk_tokenSet_24() {
7565 long[] data = { 778454232465824L, 128630951936L, 482110078976L, 0L, 0L, 0L};
7569 private static final long[] mk_tokenSet_25() {
7570 long[] data = { 8796093022976L, 0L, 0L};
7574 private static final long[] mk_tokenSet_26() {
7575 long[] data = { 3034652092538080L, 137438952448L, 507879882752L, 0L, 0L, 0L};
7579 private static final long[] mk_tokenSet_27() {
7580 long[] data = { 1908752185695456L, 137438952448L, 507879882752L, 0L, 0L, 0L};
7584 private static final long[] mk_tokenSet_28() {
7585 long[] data = { 3791116092572448L, 268435455L, 34359738368L, 0L, 0L, 0L};
7589 private static final long[] mk_tokenSet_29() {
7590 long[] data = { 3404087999595296L, 0L, 34359738368L, 0L, 0L, 0L};
7594 private static final long[] mk_tokenSet_30() {
7595 long[] data = { 1143492092887040L, 0L, 0L};
7599 private static final long[] mk_tokenSet_31() {
7600 long[] data = { 8796093022464L, 0L, 0L};
7604 private static final long[] mk_tokenSet_32() {
7605 long[] data = { 998356558021120L, 0L, 0L};
7609 private static final long[] mk_tokenSet_33() {
7610 long[] data = { 1073123348709072L, 0L, 30064771072L, 0L, 0L, 0L};
7614 private static final long[] mk_tokenSet_34() {
7615 long[] data = { 294669116243968L, 0L, 0L};
7619 private static final long[] mk_tokenSet_35() {
7620 long[] data = { 3307330976349936L, 0L, 64424509440L, 0L, 0L, 0L};
7624 private static final long[] mk_tokenSet_36() {
7625 long[] data = { 1068725302198784L, 0L, 0L};
7629 private static final long[] mk_tokenSet_37() {
7630 long[] data = { 1068725302329920L, 0L, 0L};
7634 private static final long[] mk_tokenSet_38() {
7635 long[] data = { 774056185954304L, 0L, 0L};
7639 private static final long[] mk_tokenSet_39() {
7640 long[] data = { 2199023255551600L, 111451082752L, 512174850048L, 0L, 0L, 0L};
7644 private static final long[] mk_tokenSet_40() {
7645 long[] data = { 290271069733376L, 0L, 0L};
7649 private static final long[] mk_tokenSet_41() {
7650 long[] data = { -4615969715729203216L, 111451082752L, 514322333696L, 0L, 0L, 0L};
7654 private static final long[] mk_tokenSet_42() {
7655 long[] data = { 1073123348708944L, 0L, 30064771072L, 0L, 0L, 0L};
7659 private static final long[] mk_tokenSet_43() {
7660 long[] data = { 8796092898368L, 0L, 25769803776L, 0L, 0L, 0L};
7664 private static final long[] mk_tokenSet_44() {
7665 long[] data = { 1064327255563456L, 0L, 25769803776L, 0L, 0L, 0L};
7669 private static final long[] mk_tokenSet_45() {
7670 long[] data = { 1108307720674528L, 137438953471L, 507879882752L, 0L, 0L, 0L};
7674 private static final long[] mk_tokenSet_46() {
7675 long[] data = { 1090715534753392L, 0L, 64424509440L, 0L, 0L, 0L};
7679 private static final long[] mk_tokenSet_47() {
7680 long[] data = { 1125899906842224L, 0L, 64424509440L, 0L, 0L, 0L};
7684 private static final long[] mk_tokenSet_48() {
7685 long[] data = { 281474976710656L, 0L, 0L};
7689 private static final long[] mk_tokenSet_49() {
7690 long[] data = { 4398046511232L, 0L, 0L};
7694 private static final long[] mk_tokenSet_50() {
7695 long[] data = { 256L, 0L, 0L};
7699 private static final long[] mk_tokenSet_51() {
7700 long[] data = { 8796092898624L, 0L, 25769803776L, 0L, 0L, 0L};
7704 private static final long[] mk_tokenSet_52() {
7705 long[] data = { 1090715534630624L, 0L, 60129542144L, 0L, 0L, 0L};
7709 private static final long[] mk_tokenSet_53() {
7710 long[] data = { 1086317488243232L, 0L, 34359738368L, 0L, 0L, 0L};
7714 private static final long[] mk_tokenSet_54() {
7715 long[] data = { 241892558111264L, 0L, 34359738368L, 0L, 0L, 0L};
7719 private static final long[] mk_tokenSet_55() {
7720 long[] data = { 8796093022720L, 0L, 0L};
7724 private static final long[] mk_tokenSet_56() {
7725 long[] data = { 4494803534349088L, 26843545599L, 34359738368L, 0L, 0L, 0L};
7729 private static final long[] mk_tokenSet_57() {
7730 long[] data = { -431008558088208L, -1L, 549755813887L, 0L, 0L, 0L};
7734 private static final long[] mk_tokenSet_58() {
7735 long[] data = { 8796093021264L, 0L, 32212254720L, 0L, 0L, 0L};
7739 private static final long[] mk_tokenSet_59() {
7740 long[] data = { 219902325537856L, 0L, 30064771072L, 0L, 0L, 0L};
7744 private static final long[] mk_tokenSet_60() {
7745 long[] data = { 782852278975696L, 0L, 30064771072L, 0L, 0L, 0L};
7749 private static final long[] mk_tokenSet_61() {
7750 long[] data = { -4002222325104654L, 111451082752L, 514322333696L, 0L, 0L, 0L};
7754 private static final long[] mk_tokenSet_62() {
7755 long[] data = { -4615974113775713632L, 111451082752L, 482110078976L, 0L, 0L, 0L};
7759 private static final long[] mk_tokenSet_63() {
7760 long[] data = { 800444464897248L, 137438952448L, 507879882752L, 0L, 0L, 0L};
7764 private static final long[] mk_tokenSet_64() {
7765 long[] data = { -3659174697238544L, 137438953471L, 514322333696L, 0L, 0L, 0L};
7769 private static final long[] mk_tokenSet_65() {
7770 long[] data = { -4288095348325472L, 111451082752L, 482110078976L, 0L, 0L, 0L};
7774 private static final long[] mk_tokenSet_66() {
7775 long[] data = { -3377699720527886L, 137438953471L, 514322333696L, 0L, 0L, 0L};
7779 private static final long[] mk_tokenSet_67() {
7780 long[] data = { 826832743964384L, 137438953471L, 507879882752L, 0L, 0L, 0L};
7784 private static final long[] mk_tokenSet_68() {
7785 long[] data = { 3720747348394784L, 1023L, 34359738368L, 0L, 0L, 0L};
7789 private static final long[] mk_tokenSet_69() {
7790 long[] data = { 3720747348394784L, 2047L, 34359738368L, 0L, 0L, 0L};
7794 private static final long[] mk_tokenSet_70() {
7795 long[] data = { 4499201580860384L, 137438953471L, 516469817344L, 0L, 0L, 0L};
7799 private static final long[] mk_tokenSet_71() {
7800 long[] data = { 299067162755072L, 68719476736L, 0L, 0L};
7804 private static final long[] mk_tokenSet_72() {
7805 long[] data = { 3791116092572448L, 68987912191L, 34359738368L, 0L, 0L, 0L};
7809 private static final long[] mk_tokenSet_73() {
7810 long[] data = { 307863255777280L, 0L, 0L};
7814 private static final long[] mk_tokenSet_74() {
7815 long[] data = { 3720747348394784L, 4095L, 34359738368L, 0L, 0L, 0L};
7819 private static final long[] mk_tokenSet_75() {
7820 long[] data = { 3720747348394784L, 8191L, 34359738368L, 0L, 0L, 0L};
7824 private static final long[] mk_tokenSet_76() {
7825 long[] data = { 3720747348394784L, 16383L, 34359738368L, 0L, 0L, 0L};
7829 private static final long[] mk_tokenSet_77() {
7830 long[] data = { 3720747348394784L, 32767L, 34359738368L, 0L, 0L, 0L};
7834 private static final long[] mk_tokenSet_78() {
7835 long[] data = { 3720747348394784L, 65535L, 34359738368L, 0L, 0L, 0L};
7839 private static final long[] mk_tokenSet_79() {
7840 long[] data = { 3720747348394784L, 262143L, 34359738368L, 0L, 0L, 0L};
7844 private static final long[] mk_tokenSet_80() {
7845 long[] data = { 3720747348394784L, 4194303L, 34359738368L, 0L, 0L, 0L};
7849 private static final long[] mk_tokenSet_81() {
7850 long[] data = { 3720747348394784L, 16777215L, 34359738368L, 0L, 0L, 0L};
7854 private static final long[] mk_tokenSet_82() {
7855 long[] data = { 70368744177664L, 201326592L, 0L, 0L};
7859 private static final long[] mk_tokenSet_83() {
7860 long[] data = { 3720747348394784L, 67108863L, 34359738368L, 0L, 0L, 0L};
void popScope()
pop the last scope off the scope stack.
TNode add(final String name, final TNode node)
add a node to the table with it's key as the current scope and the name
TNode lookupNameInCurrentScope(final String name)
lookup an unscoped name in the table by prepending the current scope.
void pushScope(final String s)
push a new scope onto the scope stack.
static final BitSet _tokenSet_57
final void initDeclList(AST declarationSpecifiers)
static final BitSet _tokenSet_37
static final BitSet _tokenSet_71
static final BitSet _tokenSet_10
final void functionStorageClassSpecifier()
final void declaratorParamaterList(boolean isFunctionDefinition, String declName)
final void enumList(String enumName)
static final BitSet _tokenSet_12
GnuCParser(ParserSharedInputState state)
static final BitSet _tokenSet_3
static final BitSet _tokenSet_20
static final BitSet _tokenSet_11
static boolean CPPComments
final void typeQualifier()
final void strOptExprPair()
final void storageClassSpecifier()
static final BitSet _tokenSet_38
final void postfixSuffix()
static final BitSet _tokenSet_17
static final BitSet _tokenSet_21
static final BitSet _tokenSet_47
GnuCParser(TokenStream lexer, int k)
final String declarator(boolean isFunctionDefinition)
final void conditionalExpr()
static final BitSet _tokenSet_32
static final BitSet _tokenSet_29
static final BitSet _tokenSet_8
static final BitSet _tokenSet_14
final void lcurlyInitializer()
void traceOut(String rname)
static final BitSet _tokenSet_35
final void structDeclarationList()
static final BitSet _tokenSet_36
void buildTokenTypeASTClassMap()
final void unaryOperator()
void reportError(RecognitionException ex)
void reportWarning(String s)
final void equalityExpr()
static final BitSet _tokenSet_46
final void typelessDeclaration()
final void nestedFunctionDef()
static final BitSet _tokenSet_52
static final BitSet _tokenSet_45
static final BitSet _tokenSet_81
final void statementList()
static final BitSet _tokenSet_4
GnuCParser(TokenStream lexer)
static final BitSet _tokenSet_73
static final BitSet _tokenSet_13
final void structOrUnionSpecifier()
static final BitSet _tokenSet_63
final void initializerList()
static final BitSet _tokenSet_75
static final BitSet _tokenSet_18
GnuCParser(TokenBuffer tokenBuf, int k)
void traceIn(String rname)
static final BitSet _tokenSet_79
static final BitSet _tokenSet_49
static final BitSet _tokenSet_68
static final BitSet _tokenSet_58
final void declarationList()
boolean isTypedefName(String name)
static final BitSet _tokenSet_80
void setDebug(boolean debug)
final void logicalAndExpr()
static final BitSet _tokenSet_53
static final BitSet _tokenSet_76
static final BitSet _tokenSet_6
static final BitSet _tokenSet_72
static final BitSet _tokenSet_9
static final BitSet _tokenSet_40
final void functionCall()
final void externalList()
final void enumSpecifier()
final void structDeclaratorList()
static final BitSet _tokenSet_1
final void additiveExpr()
final void exclusiveOrExpr()
static final BitSet _tokenSet_0
static final BitSet _tokenSet_82
static final BitSet _tokenSet_2
static final BitSet _tokenSet_65
static final BitSet _tokenSet_5
final void logicalOrExpr()
static final BitSet _tokenSet_62
static final BitSet _tokenSet_33
final void structOrUnion()
static final BitSet _tokenSet_42
static final BitSet _tokenSet_31
final void declarationPredictor()
static final String[] _tokenNames
final void compoundStatement(String scopeName)
static final BitSet _tokenSet_74
static final BitSet _tokenSet_61
void pushScope(String scopeName)
static final BitSet _tokenSet_64
static final BitSet _tokenSet_60
static final BitSet _tokenSet_25
static final BitSet _tokenSet_51
static final BitSet _tokenSet_34
static final BitSet _tokenSet_26
final void initializerElementLabel()
final void functionDeclSpecifiers()
static final BitSet _tokenSet_43
static final BitSet _tokenSet_24
static final BitSet _tokenSet_39
final void parameterTypeList()
static final BitSet _tokenSet_83
static final BitSet _tokenSet_22
final void functionPrefix()
static final BitSet _tokenSet_19
static final BitSet _tokenSet_44
static final BitSet _tokenSet_16
static final BitSet _tokenSet_7
static final BitSet _tokenSet_69
final void structDeclarator()
static final BitSet _tokenSet_67
static final BitSet _tokenSet_78
final void localLabelDeclaration()
final void pointerGroup()
final void relationalExpr()
final void inclusiveOrExpr()
static final BitSet _tokenSet_27
static final BitSet _tokenSet_48
static final BitSet _tokenSet_50
static final BitSet _tokenSet_54
static final BitSet _tokenSet_15
static final BitSet _tokenSet_77
final void nonemptyAbstractDeclarator()
static final BitSet _tokenSet_59
final void parameterDeclaration()
final int typeSpecifier(int specCount)
static final BitSet _tokenSet_30
static final BitSet _tokenSet_28
final void structDeclaration()
static final BitSet _tokenSet_70
final void declSpecifiers()
static final BitSet _tokenSet_56
static final BitSet _tokenSet_41
GnuCParser(TokenBuffer tokenBuf)
final void attributeDecl()
static final BitSet _tokenSet_66
final void translationUnit()
static final BitSet _tokenSet_23
final void enumerator(String enumName)
final void initDecl(AST declarationSpecifiers)
final void attributeList()
final void assignOperator()
final void specifierQualifierList()
static final BitSet _tokenSet_55
void reportError(String s)
Class TNode is an implementation of the AST interface and adds many useful features:
int getType()
Get the token type for this node.
void setText(final String text_)
Set the token text for this node.
void setAttribute(final String attrName, final Object value)
set an attribute in the attribute table.
String getText()
Get the token text for this node.
void setType(final int ttype_)
Set the token type for this node.
int NParameterDeclaration
int NInitializerElementLabel
int NNonemptyAbstractDeclarator