3 package com.jogamp.gluegen.jgram;
7 import antlr.CommonAST;
9import antlr.TokenBuffer;
10import antlr.TokenStreamException;
11import antlr.TokenStreamIOException;
12import antlr.ANTLRException;
13import antlr.LLkParser;
15import antlr.TokenStream;
16import antlr.RecognitionException;
17import antlr.NoViableAltException;
18import antlr.MismatchedTokenException;
19import antlr.SemanticException;
20import antlr.ParserSharedInputState;
21import antlr.collections.impl.BitSet;
22import antlr.collections.AST;
23import java.util.Hashtable;
24import antlr.ASTFactory;
26import antlr.collections.impl.ASTArray;
44 functionNames.clear();
56 innerInterfacesNames.clear();
61 return innerInterfacesNames;
68 innerClassesNames.clear();
73 return innerClassesNames;
76 private Set<String> functionNames =
new HashSet<String>();
78 private Set<String> enumNames =
new HashSet<String>();
79 private Set<String> innerInterfacesNames =
new HashSet<String>();
80 private Set<String> innerClassesNames =
new HashSet<String>();
82 private int blockDepth = 0;
88 astFactory =
new ASTFactory(getTokenTypeToASTClassMap());
99 astFactory =
new ASTFactory(getTokenTypeToASTClassMap());
110 astFactory =
new ASTFactory(getTokenTypeToASTClassMap());
113 public final void compilationUnit() throws RecognitionException, TokenStreamException {
116 ASTPair currentAST =
new ASTPair();
117 AST compilationUnit_AST =
null;
124 astFactory.addASTChild(currentAST, returnAST);
150 throw new NoViableAltException(
LT(1), getFilename());
159 astFactory.addASTChild(currentAST, returnAST);
172 astFactory.addASTChild(currentAST, returnAST);
180 match(Token.EOF_TYPE);
181 compilationUnit_AST = (AST)currentAST.root;
182 returnAST = compilationUnit_AST;
188 ASTPair currentAST =
new ASTPair();
189 AST packageDefinition_AST =
null;
195 p_AST = astFactory.create(p);
196 astFactory.makeASTRoot(currentAST, p_AST);
198 if ( inputState.guessing==0 ) {
202 astFactory.addASTChild(currentAST, returnAST);
204 packageDefinition_AST = (AST)currentAST.root;
206 catch (RecognitionException ex) {
207 if (inputState.guessing==0) {
214 returnAST = packageDefinition_AST;
220 ASTPair currentAST =
new ASTPair();
221 AST importDefinition_AST =
null;
227 i_AST = astFactory.create(i);
228 astFactory.makeASTRoot(currentAST, i_AST);
230 if ( inputState.guessing==0 ) {
234 astFactory.addASTChild(currentAST, returnAST);
236 importDefinition_AST = (AST)currentAST.root;
238 catch (RecognitionException ex) {
239 if (inputState.guessing==0) {
246 returnAST = importDefinition_AST;
249 public final void typeDefinition() throws RecognitionException, TokenStreamException {
252 ASTPair currentAST =
new ASTPair();
253 AST typeDefinition_AST =
null;
254 AST antsBefore_AST =
null;
256 AST antsAfter_AST =
null;
277 antsBefore_AST = (AST)returnAST;
278 astFactory.addASTChild(currentAST, returnAST);
280 m_AST = (AST)returnAST;
282 antsAfter_AST = (AST)returnAST;
283 astFactory.addASTChild(currentAST, returnAST);
289 astFactory.addASTChild(currentAST, returnAST);
295 astFactory.addASTChild(currentAST, returnAST);
300 throw new NoViableAltException(
LT(1), getFilename());
304 typeDefinition_AST = (AST)currentAST.root;
310 typeDefinition_AST = (AST)currentAST.root;
315 throw new NoViableAltException(
LT(1), getFilename());
319 catch (RecognitionException ex) {
320 if (inputState.guessing==0) {
327 returnAST = typeDefinition_AST;
330 public final void identifier() throws RecognitionException, TokenStreamException {
333 ASTPair currentAST =
new ASTPair();
334 AST identifier_AST =
null;
337 tmp5_AST = astFactory.create(
LT(1));
338 astFactory.addASTChild(currentAST, tmp5_AST);
345 tmp6_AST = astFactory.create(
LT(1));
346 astFactory.makeASTRoot(currentAST, tmp6_AST);
349 tmp7_AST = astFactory.create(
LT(1));
350 astFactory.addASTChild(currentAST, tmp7_AST);
359 identifier_AST = (AST)currentAST.root;
360 returnAST = identifier_AST;
363 public final void identifierStar() throws RecognitionException, TokenStreamException {
366 ASTPair currentAST =
new ASTPair();
367 AST identifierStar_AST =
null;
370 tmp8_AST = astFactory.create(
LT(1));
371 astFactory.addASTChild(currentAST, tmp8_AST);
376 if ((LA(1)==
DOT) && (LA(2)==
IDENT)) {
378 tmp9_AST = astFactory.create(
LT(1));
379 astFactory.makeASTRoot(currentAST, tmp9_AST);
381 AST tmp10_AST =
null;
382 tmp10_AST = astFactory.create(
LT(1));
383 astFactory.addASTChild(currentAST, tmp10_AST);
396 AST tmp11_AST =
null;
397 tmp11_AST = astFactory.create(
LT(1));
398 astFactory.makeASTRoot(currentAST, tmp11_AST);
400 AST tmp12_AST =
null;
401 tmp12_AST = astFactory.create(
LT(1));
402 astFactory.addASTChild(currentAST, tmp12_AST);
412 throw new NoViableAltException(
LT(1), getFilename());
416 identifierStar_AST = (AST)currentAST.root;
417 returnAST = identifierStar_AST;
420 public final void annotations() throws RecognitionException, TokenStreamException {
423 ASTPair currentAST =
new ASTPair();
424 AST annotations_AST =
null;
431 astFactory.addASTChild(currentAST, returnAST);
439 annotations_AST = (AST)currentAST.root;
440 returnAST = annotations_AST;
443 public final void modifiers() throws RecognitionException, TokenStreamException {
446 ASTPair currentAST =
new ASTPair();
447 AST modifiers_AST =
null;
454 astFactory.addASTChild(currentAST, returnAST);
462 if ( inputState.guessing==0 ) {
463 modifiers_AST = (AST)currentAST.root;
464 modifiers_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
MODIFIERS,
"MODIFIERS")).add(modifiers_AST));
465 currentAST.root = modifiers_AST;
466 currentAST.child = modifiers_AST!=
null &&modifiers_AST.getFirstChild()!=
null ?
467 modifiers_AST.getFirstChild() : modifiers_AST;
468 currentAST.advanceChildToEnd();
470 modifiers_AST = (AST)currentAST.root;
471 returnAST = modifiers_AST;
475 AST antsBefore, AST
modifiers, AST antsAfter
476 )
throws RecognitionException, TokenStreamException {
479 ASTPair currentAST =
new ASTPair();
480 AST classDefinition_AST =
null;
489 cn_AST = astFactory.create(cn);
492 sc_AST = (AST)returnAST;
494 ic_AST = (AST)returnAST;
496 cb_AST = (AST)returnAST;
497 if ( inputState.guessing==0 ) {
498 classDefinition_AST = (AST)currentAST.root;
499 classDefinition_AST = (AST)astFactory.make( (
new ASTArray(8)).add(astFactory.create(
CLASS_DEF,
"CLASS_DEF")).add(antsBefore).add(
modifiers).add(antsAfter).add(cn_AST).add(sc_AST).add(ic_AST).add(cb_AST));
501 innerClassesNames.add(cn.getText()); }
502 currentAST.root = classDefinition_AST;
503 currentAST.child = classDefinition_AST!=
null &&classDefinition_AST.getFirstChild()!=
null ?
504 classDefinition_AST.getFirstChild() : classDefinition_AST;
505 currentAST.advanceChildToEnd();
507 returnAST = classDefinition_AST;
511 AST antsBefore, AST
modifiers, AST antsAfter
512 )
throws RecognitionException, TokenStreamException {
515 ASTPair currentAST =
new ASTPair();
516 AST interfaceDefinition_AST =
null;
524 in_AST = astFactory.create(in);
527 ie_AST = (AST)returnAST;
529 cb_AST = (AST)returnAST;
530 if ( inputState.guessing==0 ) {
531 interfaceDefinition_AST = (AST)currentAST.root;
532 interfaceDefinition_AST = (AST)astFactory.make( (
new ASTArray(7)).add(astFactory.create(
INTERFACE_DEF,
"INTERFACE_DEF")).add(antsBefore).add(
modifiers).add(antsAfter).add(in_AST).add(ie_AST).add(cb_AST));
534 innerInterfacesNames.add(in.getText()); }
535 currentAST.root = interfaceDefinition_AST;
536 currentAST.child = interfaceDefinition_AST!=
null &&interfaceDefinition_AST.getFirstChild()!=
null ?
537 interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST;
538 currentAST.advanceChildToEnd();
540 returnAST = interfaceDefinition_AST;
546 public final void declaration() throws RecognitionException, TokenStreamException {
549 ASTPair currentAST =
new ASTPair();
550 AST declaration_AST =
null;
551 AST antsBefore_AST =
null;
553 AST antsAfter_AST =
null;
558 antsBefore_AST = (AST)returnAST;
560 m_AST = (AST)returnAST;
562 antsAfter_AST = (AST)returnAST;
564 t_AST = (AST)returnAST;
566 v_AST = (AST)returnAST;
567 if ( inputState.guessing==0 ) {
568 declaration_AST = (AST)currentAST.root;
569 declaration_AST = v_AST;
570 currentAST.root = declaration_AST;
571 currentAST.child = declaration_AST!=
null &&declaration_AST.getFirstChild()!=
null ?
572 declaration_AST.getFirstChild() : declaration_AST;
573 currentAST.advanceChildToEnd();
575 returnAST = declaration_AST;
580 )
throws RecognitionException, TokenStreamException {
583 ASTPair currentAST =
new ASTPair();
584 AST typeSpec_AST =
null;
590 astFactory.addASTChild(currentAST, returnAST);
591 typeSpec_AST = (AST)currentAST.root;
605 astFactory.addASTChild(currentAST, returnAST);
606 typeSpec_AST = (AST)currentAST.root;
611 throw new NoViableAltException(
LT(1), getFilename());
614 returnAST = typeSpec_AST;
618 AST antsBefore, AST mods, AST antsAfter, AST t
619 )
throws RecognitionException, TokenStreamException {
622 ASTPair currentAST =
new ASTPair();
623 AST variableDefinitions_AST =
null;
626 getASTFactory().dupTree(mods),
627 getASTFactory().dupTree(antsAfter),
628 getASTFactory().dupTree(t));
629 astFactory.addASTChild(currentAST, returnAST);
633 if ((LA(1)==
COMMA)) {
636 getASTFactory().dupTree(mods),
637 getASTFactory().dupTree(antsAfter),
638 getASTFactory().dupTree(t));
639 astFactory.addASTChild(currentAST, returnAST);
647 variableDefinitions_AST = (AST)currentAST.root;
648 returnAST = variableDefinitions_AST;
653 )
throws RecognitionException, TokenStreamException {
656 ASTPair currentAST =
new ASTPair();
657 AST classTypeSpec_AST =
null;
662 astFactory.addASTChild(currentAST, returnAST);
667 AST tmp16_AST =
null;
668 tmp16_AST = astFactory.create(
LT(1));
669 astFactory.addASTChild(currentAST, tmp16_AST);
676 astFactory.addASTChild(currentAST, returnAST);
681 AST tmp17_AST =
null;
682 tmp17_AST = astFactory.create(
LT(1));
683 astFactory.addASTChild(currentAST, tmp17_AST);
689 AST tmp18_AST =
null;
690 tmp18_AST = astFactory.create(
LT(1));
691 astFactory.addASTChild(currentAST, tmp18_AST);
694 astFactory.addASTChild(currentAST, returnAST);
699 AST tmp19_AST =
null;
700 tmp19_AST = astFactory.create(
LT(1));
701 astFactory.addASTChild(currentAST, tmp19_AST);
704 astFactory.addASTChild(currentAST, returnAST);
720 throw new NoViableAltException(
LT(1), getFilename());
728 throw new NoViableAltException(
LT(1), getFilename());
732 AST tmp20_AST =
null;
733 tmp20_AST = astFactory.create(
LT(1));
734 astFactory.addASTChild(currentAST, tmp20_AST);
797 throw new NoViableAltException(
LT(1), getFilename());
806 lb_AST = astFactory.create(lb);
807 astFactory.makeASTRoot(currentAST, lb_AST);
809 if ( inputState.guessing==0 ) {
820 if ( inputState.guessing==0 ) {
821 classTypeSpec_AST = (AST)currentAST.root;
824 classTypeSpec_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
TYPE,
"TYPE")).add(classTypeSpec_AST));
827 currentAST.root = classTypeSpec_AST;
828 currentAST.child = classTypeSpec_AST!=
null &&classTypeSpec_AST.getFirstChild()!=
null ?
829 classTypeSpec_AST.getFirstChild() : classTypeSpec_AST;
830 currentAST.advanceChildToEnd();
832 classTypeSpec_AST = (AST)currentAST.root;
833 returnAST = classTypeSpec_AST;
838 )
throws RecognitionException, TokenStreamException {
841 ASTPair currentAST =
new ASTPair();
842 AST builtInTypeSpec_AST =
null;
847 astFactory.addASTChild(currentAST, returnAST);
853 lb_AST = astFactory.create(lb);
854 astFactory.makeASTRoot(currentAST, lb_AST);
856 if ( inputState.guessing==0 ) {
867 if ( inputState.guessing==0 ) {
868 builtInTypeSpec_AST = (AST)currentAST.root;
871 builtInTypeSpec_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
TYPE,
"TYPE")).add(builtInTypeSpec_AST));
874 currentAST.root = builtInTypeSpec_AST;
875 currentAST.child = builtInTypeSpec_AST!=
null &&builtInTypeSpec_AST.getFirstChild()!=
null ?
876 builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST;
877 currentAST.advanceChildToEnd();
879 builtInTypeSpec_AST = (AST)currentAST.root;
880 returnAST = builtInTypeSpec_AST;
883 public final void builtInType() throws RecognitionException, TokenStreamException {
886 ASTPair currentAST =
new ASTPair();
887 AST builtInType_AST =
null;
892 AST tmp23_AST =
null;
893 tmp23_AST = astFactory.create(
LT(1));
894 astFactory.addASTChild(currentAST, tmp23_AST);
896 builtInType_AST = (AST)currentAST.root;
901 AST tmp24_AST =
null;
902 tmp24_AST = astFactory.create(
LT(1));
903 astFactory.addASTChild(currentAST, tmp24_AST);
905 builtInType_AST = (AST)currentAST.root;
910 AST tmp25_AST =
null;
911 tmp25_AST = astFactory.create(
LT(1));
912 astFactory.addASTChild(currentAST, tmp25_AST);
914 builtInType_AST = (AST)currentAST.root;
919 AST tmp26_AST =
null;
920 tmp26_AST = astFactory.create(
LT(1));
921 astFactory.addASTChild(currentAST, tmp26_AST);
923 builtInType_AST = (AST)currentAST.root;
928 AST tmp27_AST =
null;
929 tmp27_AST = astFactory.create(
LT(1));
930 astFactory.addASTChild(currentAST, tmp27_AST);
932 builtInType_AST = (AST)currentAST.root;
937 AST tmp28_AST =
null;
938 tmp28_AST = astFactory.create(
LT(1));
939 astFactory.addASTChild(currentAST, tmp28_AST);
941 builtInType_AST = (AST)currentAST.root;
946 AST tmp29_AST =
null;
947 tmp29_AST = astFactory.create(
LT(1));
948 astFactory.addASTChild(currentAST, tmp29_AST);
950 builtInType_AST = (AST)currentAST.root;
955 AST tmp30_AST =
null;
956 tmp30_AST = astFactory.create(
LT(1));
957 astFactory.addASTChild(currentAST, tmp30_AST);
959 builtInType_AST = (AST)currentAST.root;
964 AST tmp31_AST =
null;
965 tmp31_AST = astFactory.create(
LT(1));
966 astFactory.addASTChild(currentAST, tmp31_AST);
968 builtInType_AST = (AST)currentAST.root;
973 throw new NoViableAltException(
LT(1), getFilename());
976 returnAST = builtInType_AST;
979 public final void type() throws RecognitionException, TokenStreamException {
982 ASTPair currentAST =
new ASTPair();
989 astFactory.addASTChild(currentAST, returnAST);
990 type_AST = (AST)currentAST.root;
1004 astFactory.addASTChild(currentAST, returnAST);
1005 type_AST = (AST)currentAST.root;
1010 throw new NoViableAltException(
LT(1), getFilename());
1013 returnAST = type_AST;
1016 public final void modifier() throws RecognitionException, TokenStreamException {
1019 ASTPair currentAST =
new ASTPair();
1020 AST modifier_AST =
null;
1025 AST tmp32_AST =
null;
1026 tmp32_AST = astFactory.create(
LT(1));
1027 astFactory.addASTChild(currentAST, tmp32_AST);
1029 modifier_AST = (AST)currentAST.root;
1034 AST tmp33_AST =
null;
1035 tmp33_AST = astFactory.create(
LT(1));
1036 astFactory.addASTChild(currentAST, tmp33_AST);
1038 modifier_AST = (AST)currentAST.root;
1043 AST tmp34_AST =
null;
1044 tmp34_AST = astFactory.create(
LT(1));
1045 astFactory.addASTChild(currentAST, tmp34_AST);
1047 modifier_AST = (AST)currentAST.root;
1052 AST tmp35_AST =
null;
1053 tmp35_AST = astFactory.create(
LT(1));
1054 astFactory.addASTChild(currentAST, tmp35_AST);
1056 modifier_AST = (AST)currentAST.root;
1061 AST tmp36_AST =
null;
1062 tmp36_AST = astFactory.create(
LT(1));
1063 astFactory.addASTChild(currentAST, tmp36_AST);
1065 modifier_AST = (AST)currentAST.root;
1070 AST tmp37_AST =
null;
1071 tmp37_AST = astFactory.create(
LT(1));
1072 astFactory.addASTChild(currentAST, tmp37_AST);
1074 modifier_AST = (AST)currentAST.root;
1079 AST tmp38_AST =
null;
1080 tmp38_AST = astFactory.create(
LT(1));
1081 astFactory.addASTChild(currentAST, tmp38_AST);
1083 modifier_AST = (AST)currentAST.root;
1088 AST tmp39_AST =
null;
1089 tmp39_AST = astFactory.create(
LT(1));
1090 astFactory.addASTChild(currentAST, tmp39_AST);
1092 modifier_AST = (AST)currentAST.root;
1097 AST tmp40_AST =
null;
1098 tmp40_AST = astFactory.create(
LT(1));
1099 astFactory.addASTChild(currentAST, tmp40_AST);
1101 modifier_AST = (AST)currentAST.root;
1106 AST tmp41_AST =
null;
1107 tmp41_AST = astFactory.create(
LT(1));
1108 astFactory.addASTChild(currentAST, tmp41_AST);
1110 modifier_AST = (AST)currentAST.root;
1115 AST tmp42_AST =
null;
1116 tmp42_AST = astFactory.create(
LT(1));
1117 astFactory.addASTChild(currentAST, tmp42_AST);
1119 modifier_AST = (AST)currentAST.root;
1124 AST tmp43_AST =
null;
1125 tmp43_AST = astFactory.create(
LT(1));
1126 astFactory.addASTChild(currentAST, tmp43_AST);
1128 modifier_AST = (AST)currentAST.root;
1133 throw new NoViableAltException(
LT(1), getFilename());
1136 returnAST = modifier_AST;
1142 ASTPair currentAST =
new ASTPair();
1143 AST superClassClause_AST =
null;
1152 id_AST = (AST)returnAST;
1162 throw new NoViableAltException(
LT(1), getFilename());
1166 if ( inputState.guessing==0 ) {
1167 superClassClause_AST = (AST)currentAST.root;
1168 superClassClause_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
EXTENDS_CLAUSE,
"EXTENDS_CLAUSE")).add(id_AST));
1169 currentAST.root = superClassClause_AST;
1170 currentAST.child = superClassClause_AST!=
null &&superClassClause_AST.getFirstChild()!=
null ?
1171 superClassClause_AST.getFirstChild() : superClassClause_AST;
1172 currentAST.advanceChildToEnd();
1174 returnAST = superClassClause_AST;
1180 ASTPair currentAST =
new ASTPair();
1181 AST implementsClause_AST =
null;
1190 i_AST = astFactory.create(i);
1193 astFactory.addASTChild(currentAST, returnAST);
1197 if ((LA(1)==
COMMA)) {
1200 astFactory.addASTChild(currentAST, returnAST);
1216 throw new NoViableAltException(
LT(1), getFilename());
1220 if ( inputState.guessing==0 ) {
1221 implementsClause_AST = (AST)currentAST.root;
1222 implementsClause_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
IMPLEMENTS_CLAUSE,
"IMPLEMENTS_CLAUSE")).add(implementsClause_AST));
1223 currentAST.root = implementsClause_AST;
1224 currentAST.child = implementsClause_AST!=
null &&implementsClause_AST.getFirstChild()!=
null ?
1225 implementsClause_AST.getFirstChild() : implementsClause_AST;
1226 currentAST.advanceChildToEnd();
1228 implementsClause_AST = (AST)currentAST.root;
1229 returnAST = implementsClause_AST;
1232 public final void classBlock() throws RecognitionException, TokenStreamException {
1235 ASTPair currentAST =
new ASTPair();
1236 AST classBlock_AST =
null;
1239 if ( inputState.guessing==0 ) {
1274 astFactory.addASTChild(currentAST, returnAST);
1290 if ( inputState.guessing==0 ) {
1293 if ( inputState.guessing==0 ) {
1294 classBlock_AST = (AST)currentAST.root;
1295 classBlock_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
OBJBLOCK,
"OBJBLOCK")).add(classBlock_AST));
1296 currentAST.root = classBlock_AST;
1297 currentAST.child = classBlock_AST!=
null &&classBlock_AST.getFirstChild()!=
null ?
1298 classBlock_AST.getFirstChild() : classBlock_AST;
1299 currentAST.advanceChildToEnd();
1301 classBlock_AST = (AST)currentAST.root;
1302 returnAST = classBlock_AST;
1308 ASTPair currentAST =
new ASTPair();
1309 AST interfaceExtends_AST =
null;
1318 e_AST = astFactory.create(e);
1321 astFactory.addASTChild(currentAST, returnAST);
1325 if ((LA(1)==
COMMA)) {
1328 astFactory.addASTChild(currentAST, returnAST);
1344 throw new NoViableAltException(
LT(1), getFilename());
1348 if ( inputState.guessing==0 ) {
1349 interfaceExtends_AST = (AST)currentAST.root;
1350 interfaceExtends_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
EXTENDS_CLAUSE,
"EXTENDS_CLAUSE")).add(interfaceExtends_AST));
1351 currentAST.root = interfaceExtends_AST;
1352 currentAST.child = interfaceExtends_AST!=
null &&interfaceExtends_AST.getFirstChild()!=
null ?
1353 interfaceExtends_AST.getFirstChild() : interfaceExtends_AST;
1354 currentAST.advanceChildToEnd();
1356 interfaceExtends_AST = (AST)currentAST.root;
1357 returnAST = interfaceExtends_AST;
1360 public final void field() throws RecognitionException, TokenStreamException {
1363 ASTPair currentAST =
new ASTPair();
1364 AST field_AST =
null;
1365 AST antsBefore_AST =
null;
1366 AST mods_AST =
null;
1367 AST antsAfter_AST =
null;
1375 AST param_AST =
null;
1385 antsBefore_AST = (AST)returnAST;
1387 mods_AST = (AST)returnAST;
1389 antsAfter_AST = (AST)returnAST;
1395 cd_AST = (AST)returnAST;
1396 if ( inputState.guessing==0 ) {
1397 field_AST = (AST)currentAST.root;
1399 currentAST.root = field_AST;
1400 currentAST.child = field_AST!=
null &&field_AST.getFirstChild()!=
null ?
1401 field_AST.getFirstChild() : field_AST;
1402 currentAST.advanceChildToEnd();
1409 id_AST = (AST)returnAST;
1410 if ( inputState.guessing==0 ) {
1411 field_AST = (AST)currentAST.root;
1413 currentAST.root = field_AST;
1414 currentAST.child = field_AST!=
null &&field_AST.getFirstChild()!=
null ?
1415 field_AST.getFirstChild() : field_AST;
1416 currentAST.advanceChildToEnd();
1423 h_AST = (AST)returnAST;
1425 s_AST = (AST)returnAST;
1426 if ( inputState.guessing==0 ) {
1427 field_AST = (AST)currentAST.root;
1428 field_AST = (AST)astFactory.make( (
new ASTArray(6)).add(astFactory.create(
CTOR_DEF,
"CTOR_DEF")).add(antsBefore_AST).add(mods_AST).add(antsAfter_AST).add(h_AST).add(s_AST));
1429 currentAST.root = field_AST;
1430 currentAST.child = field_AST!=
null &&field_AST.getFirstChild()!=
null ?
1431 field_AST.getFirstChild() : field_AST;
1432 currentAST.advanceChildToEnd();
1437 t_AST = (AST)returnAST;
1441 fn_AST = astFactory.create(fn);
1445 param_AST = (AST)returnAST;
1448 rt_AST = (AST)returnAST;
1454 tc_AST = (AST)returnAST;
1464 throw new NoViableAltException(
LT(1), getFilename());
1473 s2_AST = (AST)returnAST;
1478 AST tmp52_AST =
null;
1479 tmp52_AST = astFactory.create(
LT(1));
1485 throw new NoViableAltException(
LT(1), getFilename());
1489 if ( inputState.guessing==0 ) {
1490 field_AST = (AST)currentAST.root;
1491 field_AST = (AST)astFactory.make( (
new ASTArray(9)).add(astFactory.create(
METHOD_DEF,
"METHOD_DEF")).add(antsBefore_AST).add(mods_AST).add(antsAfter_AST).add((AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
TYPE,
"TYPE")).add(rt_AST))).add(fn_AST).add(param_AST).add(tc_AST).add(s2_AST));
1493 functionNames.add(fn.getText()); }
1494 currentAST.root = field_AST;
1495 currentAST.child = field_AST!=
null &&field_AST.getFirstChild()!=
null ?
1496 field_AST.getFirstChild() : field_AST;
1497 currentAST.advanceChildToEnd();
1502 v_AST = (AST)returnAST;
1503 AST tmp53_AST =
null;
1504 tmp53_AST = astFactory.create(
LT(1));
1506 if ( inputState.guessing==0 ) {
1507 field_AST = (AST)currentAST.root;
1509 currentAST.root = field_AST;
1510 currentAST.child = field_AST!=
null &&field_AST.getFirstChild()!=
null ?
1511 field_AST.getFirstChild() : field_AST;
1512 currentAST.advanceChildToEnd();
1516 throw new NoViableAltException(
LT(1), getFilename());
1522 throw new NoViableAltException(
LT(1), getFilename());
1530 s3_AST = (AST)returnAST;
1531 if ( inputState.guessing==0 ) {
1532 field_AST = (AST)currentAST.root;
1533 field_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
STATIC_INIT,
"STATIC_INIT")).add(s3_AST));
1534 currentAST.root = field_AST;
1535 currentAST.child = field_AST!=
null &&field_AST.getFirstChild()!=
null ?
1536 field_AST.getFirstChild() : field_AST;
1537 currentAST.advanceChildToEnd();
1540 else if ((LA(1)==
LCURLY)) {
1542 s4_AST = (AST)returnAST;
1543 if ( inputState.guessing==0 ) {
1544 field_AST = (AST)currentAST.root;
1545 field_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
INSTANCE_INIT,
"INSTANCE_INIT")).add(s4_AST));
1546 currentAST.root = field_AST;
1547 currentAST.child = field_AST!=
null &&field_AST.getFirstChild()!=
null ?
1548 field_AST.getFirstChild() : field_AST;
1549 currentAST.advanceChildToEnd();
1553 throw new NoViableAltException(
LT(1), getFilename());
1556 returnAST = field_AST;
1559 public final void ctorHead() throws RecognitionException, TokenStreamException {
1562 ASTPair currentAST =
new ASTPair();
1563 AST ctorHead_AST =
null;
1565 AST tmp55_AST =
null;
1566 tmp55_AST = astFactory.create(
LT(1));
1567 astFactory.addASTChild(currentAST, tmp55_AST);
1571 astFactory.addASTChild(currentAST, returnAST);
1578 astFactory.addASTChild(currentAST, returnAST);
1587 throw new NoViableAltException(
LT(1), getFilename());
1591 ctorHead_AST = (AST)currentAST.root;
1592 returnAST = ctorHead_AST;
1598 ASTPair currentAST =
new ASTPair();
1599 AST constructorBody_AST =
null;
1604 lc_AST = astFactory.create(lc);
1605 astFactory.makeASTRoot(currentAST, lc_AST);
1607 if ( inputState.guessing==0 ) {
1608 lc_AST.setType(
SLIST); blockDepth++;
1613 astFactory.addASTChild(currentAST, returnAST);
1618 throw new NoViableAltException(
LT(1), getFilename());
1627 astFactory.addASTChild(currentAST, returnAST);
1636 if ( inputState.guessing==0 ) {
1639 constructorBody_AST = (AST)currentAST.root;
1640 returnAST = constructorBody_AST;
1646 ASTPair currentAST =
new ASTPair();
1647 AST parameterDeclarationList_AST =
null;
1665 astFactory.addASTChild(currentAST, returnAST);
1669 if ((LA(1)==
COMMA)) {
1672 astFactory.addASTChild(currentAST, returnAST);
1688 throw new NoViableAltException(
LT(1), getFilename());
1692 if ( inputState.guessing==0 ) {
1693 parameterDeclarationList_AST = (AST)currentAST.root;
1694 parameterDeclarationList_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
PARAMETERS,
"PARAMETERS")).add(parameterDeclarationList_AST));
1695 currentAST.root = parameterDeclarationList_AST;
1696 currentAST.child = parameterDeclarationList_AST!=
null &¶meterDeclarationList_AST.getFirstChild()!=
null ?
1697 parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST;
1698 currentAST.advanceChildToEnd();
1700 parameterDeclarationList_AST = (AST)currentAST.root;
1701 returnAST = parameterDeclarationList_AST;
1706 )
throws RecognitionException, TokenStreamException {
1709 ASTPair currentAST =
new ASTPair();
1710 AST declaratorBrackets_AST =
null;
1714 if ( inputState.guessing==0 ) {
1715 declaratorBrackets_AST = (AST)currentAST.root;
1716 declaratorBrackets_AST=typ;
1717 currentAST.root = declaratorBrackets_AST;
1718 currentAST.child = declaratorBrackets_AST!=
null &&declaratorBrackets_AST.getFirstChild()!=
null ?
1719 declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST;
1720 currentAST.advanceChildToEnd();
1727 lb_AST = astFactory.create(lb);
1728 astFactory.makeASTRoot(currentAST, lb_AST);
1730 if ( inputState.guessing==0 ) {
1741 declaratorBrackets_AST = (AST)currentAST.root;
1742 returnAST = declaratorBrackets_AST;
1745 public final void throwsClause() throws RecognitionException, TokenStreamException {
1748 ASTPair currentAST =
new ASTPair();
1749 AST throwsClause_AST =
null;
1751 AST tmp61_AST =
null;
1752 tmp61_AST = astFactory.create(
LT(1));
1753 astFactory.makeASTRoot(currentAST, tmp61_AST);
1756 astFactory.addASTChild(currentAST, returnAST);
1760 if ((LA(1)==
COMMA)) {
1763 astFactory.addASTChild(currentAST, returnAST);
1771 throwsClause_AST = (AST)currentAST.root;
1772 returnAST = throwsClause_AST;
1778 ASTPair currentAST =
new ASTPair();
1779 AST compoundStatement_AST =
null;
1784 lc_AST = astFactory.create(lc);
1785 astFactory.makeASTRoot(currentAST, lc_AST);
1787 if ( inputState.guessing==0 ) {
1788 lc_AST.setType(
SLIST); blockDepth++;
1795 astFactory.addASTChild(currentAST, returnAST);
1804 if ( inputState.guessing==0 ) {
1807 compoundStatement_AST = (AST)currentAST.root;
1808 returnAST = compoundStatement_AST;
1815 ASTPair currentAST =
new ASTPair();
1816 AST explicitConstructorInvocation_AST =
null;
1827 lp1_AST = astFactory.create(lp1);
1828 astFactory.makeASTRoot(currentAST, lp1_AST);
1831 astFactory.addASTChild(currentAST, returnAST);
1834 if ( inputState.guessing==0 ) {
1837 explicitConstructorInvocation_AST = (AST)currentAST.root;
1844 lp2_AST = astFactory.create(lp2);
1845 astFactory.makeASTRoot(currentAST, lp2_AST);
1848 astFactory.addASTChild(currentAST, returnAST);
1851 if ( inputState.guessing==0 ) {
1854 explicitConstructorInvocation_AST = (AST)currentAST.root;
1859 throw new NoViableAltException(
LT(1), getFilename());
1862 returnAST = explicitConstructorInvocation_AST;
1865 public final void statement() throws RecognitionException, TokenStreamException {
1868 ASTPair currentAST =
new ASTPair();
1869 AST statement_AST =
null;
1870 AST antsBefore_AST =
null;
1872 AST antsAfter_AST =
null;
1882 astFactory.addASTChild(currentAST, returnAST);
1883 statement_AST = (AST)currentAST.root;
1888 AST tmp70_AST =
null;
1889 tmp70_AST = astFactory.create(
LT(1));
1890 astFactory.makeASTRoot(currentAST, tmp70_AST);
1894 astFactory.addASTChild(currentAST, returnAST);
1897 astFactory.addASTChild(currentAST, returnAST);
1902 astFactory.addASTChild(currentAST, returnAST);
1907 throw new NoViableAltException(
LT(1), getFilename());
1911 statement_AST = (AST)currentAST.root;
1916 AST tmp74_AST =
null;
1917 tmp74_AST = astFactory.create(
LT(1));
1918 astFactory.makeASTRoot(currentAST, tmp74_AST);
1922 astFactory.addASTChild(currentAST, returnAST);
1925 astFactory.addASTChild(currentAST, returnAST);
1928 astFactory.addASTChild(currentAST, returnAST);
1931 astFactory.addASTChild(currentAST, returnAST);
1932 statement_AST = (AST)currentAST.root;
1937 AST tmp79_AST =
null;
1938 tmp79_AST = astFactory.create(
LT(1));
1939 astFactory.makeASTRoot(currentAST, tmp79_AST);
1943 astFactory.addASTChild(currentAST, returnAST);
1946 astFactory.addASTChild(currentAST, returnAST);
1947 statement_AST = (AST)currentAST.root;
1952 AST tmp82_AST =
null;
1953 tmp82_AST = astFactory.create(
LT(1));
1954 astFactory.makeASTRoot(currentAST, tmp82_AST);
1957 astFactory.addASTChild(currentAST, returnAST);
1961 astFactory.addASTChild(currentAST, returnAST);
1964 statement_AST = (AST)currentAST.root;
1969 AST tmp87_AST =
null;
1970 tmp87_AST = astFactory.create(
LT(1));
1971 astFactory.makeASTRoot(currentAST, tmp87_AST);
1977 AST tmp88_AST =
null;
1978 tmp88_AST = astFactory.create(
LT(1));
1979 astFactory.addASTChild(currentAST, tmp88_AST);
1989 throw new NoViableAltException(
LT(1), getFilename());
1994 statement_AST = (AST)currentAST.root;
1999 AST tmp90_AST =
null;
2000 tmp90_AST = astFactory.create(
LT(1));
2001 astFactory.makeASTRoot(currentAST, tmp90_AST);
2007 AST tmp91_AST =
null;
2008 tmp91_AST = astFactory.create(
LT(1));
2009 astFactory.addASTChild(currentAST, tmp91_AST);
2019 throw new NoViableAltException(
LT(1), getFilename());
2024 statement_AST = (AST)currentAST.root;
2029 AST tmp93_AST =
null;
2030 tmp93_AST = astFactory.create(
LT(1));
2031 astFactory.makeASTRoot(currentAST, tmp93_AST);
2066 astFactory.addASTChild(currentAST, returnAST);
2075 throw new NoViableAltException(
LT(1), getFilename());
2080 statement_AST = (AST)currentAST.root;
2085 AST tmp95_AST =
null;
2086 tmp95_AST = astFactory.create(
LT(1));
2087 astFactory.makeASTRoot(currentAST, tmp95_AST);
2091 astFactory.addASTChild(currentAST, returnAST);
2094 if ( inputState.guessing==0 ) {
2102 astFactory.addASTChild(currentAST, returnAST);
2111 if ( inputState.guessing==0 ) {
2114 statement_AST = (AST)currentAST.root;
2120 astFactory.addASTChild(currentAST, returnAST);
2121 statement_AST = (AST)currentAST.root;
2126 AST tmp100_AST =
null;
2127 tmp100_AST = astFactory.create(
LT(1));
2128 astFactory.makeASTRoot(currentAST, tmp100_AST);
2131 astFactory.addASTChild(currentAST, returnAST);
2133 statement_AST = (AST)currentAST.root;
2139 s_AST = astFactory.create(s);
2140 astFactory.addASTChild(currentAST, s_AST);
2142 if ( inputState.guessing==0 ) {
2145 statement_AST = (AST)currentAST.root;
2149 boolean synPredMatched94 =
false;
2152 synPredMatched94 =
true;
2153 inputState.guessing++;
2159 catch (RecognitionException pe) {
2160 synPredMatched94 =
false;
2163inputState.guessing--;
2165 if ( synPredMatched94 ) {
2167 astFactory.addASTChild(currentAST, returnAST);
2169 statement_AST = (AST)currentAST.root;
2173 astFactory.addASTChild(currentAST, returnAST);
2175 statement_AST = (AST)currentAST.root;
2179 antsBefore_AST = (AST)returnAST;
2180 astFactory.addASTChild(currentAST, returnAST);
2182 m_AST = (AST)returnAST;
2184 antsAfter_AST = (AST)returnAST;
2185 astFactory.addASTChild(currentAST, returnAST);
2187 astFactory.addASTChild(currentAST, returnAST);
2188 statement_AST = (AST)currentAST.root;
2191 AST tmp104_AST =
null;
2192 tmp104_AST = astFactory.create(
LT(1));
2193 astFactory.addASTChild(currentAST, tmp104_AST);
2196 c_AST = astFactory.create(c);
2197 astFactory.makeASTRoot(currentAST, c_AST);
2199 if ( inputState.guessing==0 ) {
2203 astFactory.addASTChild(currentAST, returnAST);
2204 statement_AST = (AST)currentAST.root;
2207 AST tmp105_AST =
null;
2208 tmp105_AST = astFactory.create(
LT(1));
2209 astFactory.makeASTRoot(currentAST, tmp105_AST);
2213 astFactory.addASTChild(currentAST, returnAST);
2216 astFactory.addASTChild(currentAST, returnAST);
2217 statement_AST = (AST)currentAST.root;
2220 throw new NoViableAltException(
LT(1), getFilename());
2223 returnAST = statement_AST;
2226 public final void argList() throws RecognitionException, TokenStreamException {
2229 ASTPair currentAST =
new ASTPair();
2230 AST argList_AST =
null;
2265 astFactory.addASTChild(currentAST, returnAST);
2270 if ( inputState.guessing==0 ) {
2271 argList_AST = (AST)currentAST.root;
2272 argList_AST = astFactory.create(
ELIST,
"ELIST");
2273 currentAST.root = argList_AST;
2274 currentAST.child = argList_AST!=
null &&argList_AST.getFirstChild()!=
null ?
2275 argList_AST.getFirstChild() : argList_AST;
2276 currentAST.advanceChildToEnd();
2282 throw new NoViableAltException(
LT(1), getFilename());
2286 argList_AST = (AST)currentAST.root;
2287 returnAST = argList_AST;
2295 AST antsBefore, AST mods, AST antsAfter, AST t
2296 )
throws RecognitionException, TokenStreamException {
2299 ASTPair currentAST =
new ASTPair();
2300 AST variableDeclarator_AST =
null;
2307 id_AST = astFactory.create(
id);
2310 d_AST = (AST)returnAST;
2312 v_AST = (AST)returnAST;
2313 if ( inputState.guessing==0 ) {
2314 variableDeclarator_AST = (AST)currentAST.root;
2315 variableDeclarator_AST = (AST)astFactory.make( (
new ASTArray(7)).add(astFactory.create(
VARIABLE_DEF,
"VARIABLE_DEF")).add(antsBefore).add(mods).add(antsAfter).add((AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
TYPE,
"TYPE")).add(d_AST))).add(id_AST).add(v_AST));
2317 enumNames.add(
id.getText());
2320 currentAST.root = variableDeclarator_AST;
2321 currentAST.child = variableDeclarator_AST!=
null &&variableDeclarator_AST.getFirstChild()!=
null ?
2322 variableDeclarator_AST.getFirstChild() : variableDeclarator_AST;
2323 currentAST.advanceChildToEnd();
2325 returnAST = variableDeclarator_AST;
2328 public final void varInitializer() throws RecognitionException, TokenStreamException {
2331 ASTPair currentAST =
new ASTPair();
2332 AST varInitializer_AST =
null;
2338 AST tmp108_AST =
null;
2339 tmp108_AST = astFactory.create(
LT(1));
2340 astFactory.makeASTRoot(currentAST, tmp108_AST);
2343 astFactory.addASTChild(currentAST, returnAST);
2353 throw new NoViableAltException(
LT(1), getFilename());
2357 varInitializer_AST = (AST)currentAST.root;
2358 returnAST = varInitializer_AST;
2361 public final void initializer() throws RecognitionException, TokenStreamException {
2364 ASTPair currentAST =
new ASTPair();
2365 AST initializer_AST =
null;
2399 astFactory.addASTChild(currentAST, returnAST);
2400 initializer_AST = (AST)currentAST.root;
2406 astFactory.addASTChild(currentAST, returnAST);
2407 initializer_AST = (AST)currentAST.root;
2412 throw new NoViableAltException(
LT(1), getFilename());
2415 returnAST = initializer_AST;
2421 ASTPair currentAST =
new ASTPair();
2422 AST arrayInitializer_AST =
null;
2427 lc_AST = astFactory.create(lc);
2428 astFactory.makeASTRoot(currentAST, lc_AST);
2430 if ( inputState.guessing==0 ) {
2467 astFactory.addASTChild(currentAST, returnAST);
2474 astFactory.addASTChild(currentAST, returnAST);
2495 throw new NoViableAltException(
LT(1), getFilename());
2507 throw new NoViableAltException(
LT(1), getFilename());
2512 if ( inputState.guessing==0 ) {
2515 arrayInitializer_AST = (AST)currentAST.root;
2516 returnAST = arrayInitializer_AST;
2519 public final void expression() throws RecognitionException, TokenStreamException {
2522 ASTPair currentAST =
new ASTPair();
2523 AST expression_AST =
null;
2526 astFactory.addASTChild(currentAST, returnAST);
2527 if ( inputState.guessing==0 ) {
2528 expression_AST = (AST)currentAST.root;
2529 expression_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
EXPR,
"EXPR")).add(expression_AST));
2530 currentAST.root = expression_AST;
2531 currentAST.child = expression_AST!=
null &&expression_AST.getFirstChild()!=
null ?
2532 expression_AST.getFirstChild() : expression_AST;
2533 currentAST.advanceChildToEnd();
2535 expression_AST = (AST)currentAST.root;
2536 returnAST = expression_AST;
2542 ASTPair currentAST =
new ASTPair();
2543 AST parameterDeclaration_AST =
null;
2544 AST antsBefore_AST =
null;
2546 AST antsAfter_AST =
null;
2553 antsBefore_AST = (AST)returnAST;
2555 pm_AST = (AST)returnAST;
2557 antsAfter_AST = (AST)returnAST;
2559 t_AST = (AST)returnAST;
2561 id_AST = astFactory.create(
id);
2564 pd_AST = (AST)returnAST;
2565 if ( inputState.guessing==0 ) {
2566 parameterDeclaration_AST = (AST)currentAST.root;
2567 parameterDeclaration_AST = (AST)astFactory.make( (
new ASTArray(6)).add(astFactory.create(
PARAMETER_DEF,
"PARAMETER_DEF")).add(antsBefore_AST).add(pm_AST).add(antsAfter_AST).add((AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
TYPE,
"TYPE")).add(pd_AST))).add(id_AST));
2568 currentAST.root = parameterDeclaration_AST;
2569 currentAST.child = parameterDeclaration_AST!=
null &¶meterDeclaration_AST.getFirstChild()!=
null ?
2570 parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST;
2571 currentAST.advanceChildToEnd();
2573 returnAST = parameterDeclaration_AST;
2579 ASTPair currentAST =
new ASTPair();
2580 AST parameterModifier_AST =
null;
2589 f_AST = astFactory.create(f);
2590 astFactory.addASTChild(currentAST, f_AST);
2610 throw new NoViableAltException(
LT(1), getFilename());
2614 if ( inputState.guessing==0 ) {
2615 parameterModifier_AST = (AST)currentAST.root;
2616 parameterModifier_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
MODIFIERS,
"MODIFIERS")).add(f_AST));
2617 currentAST.root = parameterModifier_AST;
2618 currentAST.child = parameterModifier_AST!=
null &¶meterModifier_AST.getFirstChild()!=
null ?
2619 parameterModifier_AST.getFirstChild() : parameterModifier_AST;
2620 currentAST.advanceChildToEnd();
2622 parameterModifier_AST = (AST)currentAST.root;
2623 returnAST = parameterModifier_AST;
2626 public final void forInit() throws RecognitionException, TokenStreamException {
2629 ASTPair currentAST =
new ASTPair();
2630 AST forInit_AST =
null;
2633 boolean synPredMatched112 =
false;
2636 synPredMatched112 =
true;
2637 inputState.guessing++;
2643 catch (RecognitionException pe) {
2644 synPredMatched112 =
false;
2647inputState.guessing--;
2649 if ( synPredMatched112 ) {
2651 astFactory.addASTChild(currentAST, returnAST);
2655 astFactory.addASTChild(currentAST, returnAST);
2657 else if ((LA(1)==
SEMI)) {
2660 throw new NoViableAltException(
LT(1), getFilename());
2664 if ( inputState.guessing==0 ) {
2665 forInit_AST = (AST)currentAST.root;
2666 forInit_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
FOR_INIT,
"FOR_INIT")).add(forInit_AST));
2667 currentAST.root = forInit_AST;
2668 currentAST.child = forInit_AST!=
null &&forInit_AST.getFirstChild()!=
null ?
2669 forInit_AST.getFirstChild() : forInit_AST;
2670 currentAST.advanceChildToEnd();
2672 forInit_AST = (AST)currentAST.root;
2673 returnAST = forInit_AST;
2676 public final void forCond() throws RecognitionException, TokenStreamException {
2679 ASTPair currentAST =
new ASTPair();
2680 AST forCond_AST =
null;
2715 astFactory.addASTChild(currentAST, returnAST);
2724 throw new NoViableAltException(
LT(1), getFilename());
2728 if ( inputState.guessing==0 ) {
2729 forCond_AST = (AST)currentAST.root;
2730 forCond_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
FOR_CONDITION,
"FOR_CONDITION")).add(forCond_AST));
2731 currentAST.root = forCond_AST;
2732 currentAST.child = forCond_AST!=
null &&forCond_AST.getFirstChild()!=
null ?
2733 forCond_AST.getFirstChild() : forCond_AST;
2734 currentAST.advanceChildToEnd();
2736 forCond_AST = (AST)currentAST.root;
2737 returnAST = forCond_AST;
2740 public final void forIter() throws RecognitionException, TokenStreamException {
2743 ASTPair currentAST =
new ASTPair();
2744 AST forIter_AST =
null;
2779 astFactory.addASTChild(currentAST, returnAST);
2788 throw new NoViableAltException(
LT(1), getFilename());
2792 if ( inputState.guessing==0 ) {
2793 forIter_AST = (AST)currentAST.root;
2794 forIter_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
FOR_ITERATOR,
"FOR_ITERATOR")).add(forIter_AST));
2795 currentAST.root = forIter_AST;
2796 currentAST.child = forIter_AST!=
null &&forIter_AST.getFirstChild()!=
null ?
2797 forIter_AST.getFirstChild() : forIter_AST;
2798 currentAST.advanceChildToEnd();
2800 forIter_AST = (AST)currentAST.root;
2801 returnAST = forIter_AST;
2804 public final void casesGroup() throws RecognitionException, TokenStreamException {
2807 ASTPair currentAST =
new ASTPair();
2808 AST casesGroup_AST =
null;
2816 astFactory.addASTChild(currentAST, returnAST);
2819 if ( _cnt103>=1 ) {
break _loop103; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
2826 astFactory.addASTChild(currentAST, returnAST);
2827 if ( inputState.guessing==0 ) {
2828 casesGroup_AST = (AST)currentAST.root;
2829 casesGroup_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
CASE_GROUP,
"CASE_GROUP")).add(casesGroup_AST));
2830 currentAST.root = casesGroup_AST;
2831 currentAST.child = casesGroup_AST!=
null &&casesGroup_AST.getFirstChild()!=
null ?
2832 casesGroup_AST.getFirstChild() : casesGroup_AST;
2833 currentAST.advanceChildToEnd();
2835 casesGroup_AST = (AST)currentAST.root;
2836 returnAST = casesGroup_AST;
2839 public final void tryBlock() throws RecognitionException, TokenStreamException {
2842 ASTPair currentAST =
new ASTPair();
2843 AST tryBlock_AST =
null;
2845 AST tmp112_AST =
null;
2846 tmp112_AST = astFactory.create(
LT(1));
2847 astFactory.makeASTRoot(currentAST, tmp112_AST);
2850 astFactory.addASTChild(currentAST, returnAST);
2856 astFactory.addASTChild(currentAST, returnAST);
2869 astFactory.addASTChild(currentAST, returnAST);
2936 throw new NoViableAltException(
LT(1), getFilename());
2940 tryBlock_AST = (AST)currentAST.root;
2941 returnAST = tryBlock_AST;
2944 public final void aCase() throws RecognitionException, TokenStreamException {
2947 ASTPair currentAST =
new ASTPair();
2948 AST aCase_AST =
null;
2954 AST tmp113_AST =
null;
2955 tmp113_AST = astFactory.create(
LT(1));
2956 astFactory.makeASTRoot(currentAST, tmp113_AST);
2959 astFactory.addASTChild(currentAST, returnAST);
2964 AST tmp114_AST =
null;
2965 tmp114_AST = astFactory.create(
LT(1));
2966 astFactory.addASTChild(currentAST, tmp114_AST);
2972 throw new NoViableAltException(
LT(1), getFilename());
2977 aCase_AST = (AST)currentAST.root;
2978 returnAST = aCase_AST;
2981 public final void caseSList() throws RecognitionException, TokenStreamException {
2984 ASTPair currentAST =
new ASTPair();
2985 AST caseSList_AST =
null;
2992 astFactory.addASTChild(currentAST, returnAST);
3000 if ( inputState.guessing==0 ) {
3001 caseSList_AST = (AST)currentAST.root;
3002 caseSList_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
SLIST,
"SLIST")).add(caseSList_AST));
3003 currentAST.root = caseSList_AST;
3004 currentAST.child = caseSList_AST!=
null &&caseSList_AST.getFirstChild()!=
null ?
3005 caseSList_AST.getFirstChild() : caseSList_AST;
3006 currentAST.advanceChildToEnd();
3008 caseSList_AST = (AST)currentAST.root;
3009 returnAST = caseSList_AST;
3012 public final void expressionList() throws RecognitionException, TokenStreamException {
3015 ASTPair currentAST =
new ASTPair();
3016 AST expressionList_AST =
null;
3019 astFactory.addASTChild(currentAST, returnAST);
3023 if ((LA(1)==
COMMA)) {
3026 astFactory.addASTChild(currentAST, returnAST);
3034 if ( inputState.guessing==0 ) {
3035 expressionList_AST = (AST)currentAST.root;
3036 expressionList_AST = (AST)astFactory.make( (
new ASTArray(2)).add(astFactory.create(
ELIST,
"ELIST")).add(expressionList_AST));
3037 currentAST.root = expressionList_AST;
3038 currentAST.child = expressionList_AST!=
null &&expressionList_AST.getFirstChild()!=
null ?
3039 expressionList_AST.getFirstChild() : expressionList_AST;
3040 currentAST.advanceChildToEnd();
3042 expressionList_AST = (AST)currentAST.root;
3043 returnAST = expressionList_AST;
3046 public final void handler() throws RecognitionException, TokenStreamException {
3049 ASTPair currentAST =
new ASTPair();
3050 AST handler_AST =
null;
3052 AST tmp117_AST =
null;
3053 tmp117_AST = astFactory.create(
LT(1));
3054 astFactory.makeASTRoot(currentAST, tmp117_AST);
3058 astFactory.addASTChild(currentAST, returnAST);
3061 astFactory.addASTChild(currentAST, returnAST);
3062 handler_AST = (AST)currentAST.root;
3063 returnAST = handler_AST;
3066 public final void finallyClause() throws RecognitionException, TokenStreamException {
3069 ASTPair currentAST =
new ASTPair();
3070 AST finallyClause_AST =
null;
3072 AST tmp120_AST =
null;
3073 tmp120_AST = astFactory.create(
LT(1));
3074 astFactory.makeASTRoot(currentAST, tmp120_AST);
3077 astFactory.addASTChild(currentAST, returnAST);
3078 finallyClause_AST = (AST)currentAST.root;
3079 returnAST = finallyClause_AST;
3082 public final void annotation() throws RecognitionException, TokenStreamException {
3085 ASTPair currentAST =
new ASTPair();
3086 AST annotation_AST =
null;
3087 AST type_AST =
null;
3088 AST content_AST =
null;
3091 AST tmp121_AST =
null;
3092 tmp121_AST = astFactory.create(
LT(1));
3093 astFactory.addASTChild(currentAST, tmp121_AST);
3096 type_AST = (AST)returnAST;
3097 astFactory.addASTChild(currentAST, returnAST);
3102 AST tmp122_AST =
null;
3103 tmp122_AST = astFactory.create(
LT(1));
3104 astFactory.addASTChild(currentAST, tmp122_AST);
3109 content_AST = (AST)returnAST;
3110 astFactory.addASTChild(currentAST, returnAST);
3114 astFactory.addASTChild(currentAST, returnAST);
3115 AST tmp123_AST =
null;
3116 tmp123_AST = astFactory.create(
LT(1));
3117 astFactory.addASTChild(currentAST, tmp123_AST);
3120 astFactory.addASTChild(currentAST, returnAST);
3124 if ((LA(1)==
COMMA)) {
3125 AST tmp124_AST =
null;
3126 tmp124_AST = astFactory.create(
LT(1));
3127 astFactory.addASTChild(currentAST, tmp124_AST);
3130 astFactory.addASTChild(currentAST, returnAST);
3131 AST tmp125_AST =
null;
3132 tmp125_AST = astFactory.create(
LT(1));
3133 astFactory.addASTChild(currentAST, tmp125_AST);
3136 astFactory.addASTChild(currentAST, returnAST);
3146 throw new NoViableAltException(
LT(1), getFilename());
3150 AST tmp126_AST =
null;
3151 tmp126_AST = astFactory.create(
LT(1));
3152 astFactory.addASTChild(currentAST, tmp126_AST);
3186 throw new NoViableAltException(
LT(1), getFilename());
3191 annotation_AST = (AST)currentAST.root;
3192 returnAST = annotation_AST;
3198 ASTPair currentAST =
new ASTPair();
3199 AST primaryExpression_AST =
null;
3207 astFactory.addASTChild(currentAST, returnAST);
3210 AST tmp127_AST =
null;
3211 tmp127_AST = astFactory.create(
LT(1));
3212 astFactory.makeASTRoot(currentAST, tmp127_AST);
3214 AST tmp128_AST =
null;
3215 tmp128_AST = astFactory.create(
LT(1));
3216 astFactory.addASTChild(currentAST, tmp128_AST);
3222 throw new NoViableAltException(
LT(1), getFilename());
3226 primaryExpression_AST = (AST)currentAST.root;
3237 astFactory.addASTChild(currentAST, returnAST);
3238 primaryExpression_AST = (AST)currentAST.root;
3243 AST tmp129_AST =
null;
3244 tmp129_AST = astFactory.create(
LT(1));
3245 astFactory.addASTChild(currentAST, tmp129_AST);
3247 primaryExpression_AST = (AST)currentAST.root;
3252 AST tmp130_AST =
null;
3253 tmp130_AST = astFactory.create(
LT(1));
3254 astFactory.addASTChild(currentAST, tmp130_AST);
3256 primaryExpression_AST = (AST)currentAST.root;
3261 AST tmp131_AST =
null;
3262 tmp131_AST = astFactory.create(
LT(1));
3263 astFactory.addASTChild(currentAST, tmp131_AST);
3265 primaryExpression_AST = (AST)currentAST.root;
3271 astFactory.addASTChild(currentAST, returnAST);
3272 primaryExpression_AST = (AST)currentAST.root;
3277 AST tmp132_AST =
null;
3278 tmp132_AST = astFactory.create(
LT(1));
3279 astFactory.addASTChild(currentAST, tmp132_AST);
3281 primaryExpression_AST = (AST)currentAST.root;
3286 AST tmp133_AST =
null;
3287 tmp133_AST = astFactory.create(
LT(1));
3288 astFactory.addASTChild(currentAST, tmp133_AST);
3290 primaryExpression_AST = (AST)currentAST.root;
3297 astFactory.addASTChild(currentAST, returnAST);
3299 primaryExpression_AST = (AST)currentAST.root;
3313 astFactory.addASTChild(currentAST, returnAST);
3319 lbt_AST = astFactory.create(lbt);
3320 astFactory.makeASTRoot(currentAST, lbt_AST);
3322 if ( inputState.guessing==0 ) {
3333 AST tmp137_AST =
null;
3334 tmp137_AST = astFactory.create(
LT(1));
3335 astFactory.makeASTRoot(currentAST, tmp137_AST);
3337 AST tmp138_AST =
null;
3338 tmp138_AST = astFactory.create(
LT(1));
3339 astFactory.addASTChild(currentAST, tmp138_AST);
3341 primaryExpression_AST = (AST)currentAST.root;
3346 throw new NoViableAltException(
LT(1), getFilename());
3349 returnAST = primaryExpression_AST;
3356 public final void identPrimary() throws RecognitionException, TokenStreamException {
3359 ASTPair currentAST =
new ASTPair();
3360 AST identPrimary_AST =
null;
3366 AST tmp139_AST =
null;
3367 tmp139_AST = astFactory.create(
LT(1));
3368 astFactory.addASTChild(currentAST, tmp139_AST);
3373 if ((LA(1)==
DOT) && (LA(2)==
IDENT)) {
3374 AST tmp140_AST =
null;
3375 tmp140_AST = astFactory.create(
LT(1));
3376 astFactory.makeASTRoot(currentAST, tmp140_AST);
3378 AST tmp141_AST =
null;
3379 tmp141_AST = astFactory.create(
LT(1));
3380 astFactory.addASTChild(currentAST, tmp141_AST);
3393 lp_AST = astFactory.create(lp);
3394 astFactory.makeASTRoot(currentAST, lp_AST);
3396 if ( inputState.guessing==0 ) {
3400 astFactory.addASTChild(currentAST, returnAST);
3411 lbc_AST = astFactory.create(lbc);
3412 astFactory.makeASTRoot(currentAST, lbc_AST);
3414 if ( inputState.guessing==0 ) {
3420 if ( _cnt200>=1 ) {
break _loop200; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
3430 throw new NoViableAltException(
LT(1), getFilename());
3434 identPrimary_AST = (AST)currentAST.root;
3435 returnAST = identPrimary_AST;
3441 ASTPair currentAST =
new ASTPair();
3442 AST assignmentExpression_AST =
null;
3445 astFactory.addASTChild(currentAST, returnAST);
3465 AST tmp144_AST =
null;
3466 tmp144_AST = astFactory.create(
LT(1));
3467 astFactory.makeASTRoot(currentAST, tmp144_AST);
3473 AST tmp145_AST =
null;
3474 tmp145_AST = astFactory.create(
LT(1));
3475 astFactory.makeASTRoot(currentAST, tmp145_AST);
3481 AST tmp146_AST =
null;
3482 tmp146_AST = astFactory.create(
LT(1));
3483 astFactory.makeASTRoot(currentAST, tmp146_AST);
3489 AST tmp147_AST =
null;
3490 tmp147_AST = astFactory.create(
LT(1));
3491 astFactory.makeASTRoot(currentAST, tmp147_AST);
3497 AST tmp148_AST =
null;
3498 tmp148_AST = astFactory.create(
LT(1));
3499 astFactory.makeASTRoot(currentAST, tmp148_AST);
3505 AST tmp149_AST =
null;
3506 tmp149_AST = astFactory.create(
LT(1));
3507 astFactory.makeASTRoot(currentAST, tmp149_AST);
3513 AST tmp150_AST =
null;
3514 tmp150_AST = astFactory.create(
LT(1));
3515 astFactory.makeASTRoot(currentAST, tmp150_AST);
3521 AST tmp151_AST =
null;
3522 tmp151_AST = astFactory.create(
LT(1));
3523 astFactory.makeASTRoot(currentAST, tmp151_AST);
3529 AST tmp152_AST =
null;
3530 tmp152_AST = astFactory.create(
LT(1));
3531 astFactory.makeASTRoot(currentAST, tmp152_AST);
3537 AST tmp153_AST =
null;
3538 tmp153_AST = astFactory.create(
LT(1));
3539 astFactory.makeASTRoot(currentAST, tmp153_AST);
3545 AST tmp154_AST =
null;
3546 tmp154_AST = astFactory.create(
LT(1));
3547 astFactory.makeASTRoot(currentAST, tmp154_AST);
3553 AST tmp155_AST =
null;
3554 tmp155_AST = astFactory.create(
LT(1));
3555 astFactory.makeASTRoot(currentAST, tmp155_AST);
3561 throw new NoViableAltException(
LT(1), getFilename());
3566 astFactory.addASTChild(currentAST, returnAST);
3580 throw new NoViableAltException(
LT(1), getFilename());
3584 assignmentExpression_AST = (AST)currentAST.root;
3585 returnAST = assignmentExpression_AST;
3591 ASTPair currentAST =
new ASTPair();
3592 AST conditionalExpression_AST =
null;
3595 astFactory.addASTChild(currentAST, returnAST);
3600 AST tmp156_AST =
null;
3601 tmp156_AST = astFactory.create(
LT(1));
3602 astFactory.makeASTRoot(currentAST, tmp156_AST);
3605 astFactory.addASTChild(currentAST, returnAST);
3608 astFactory.addASTChild(currentAST, returnAST);
3634 throw new NoViableAltException(
LT(1), getFilename());
3638 conditionalExpression_AST = (AST)currentAST.root;
3639 returnAST = conditionalExpression_AST;
3645 ASTPair currentAST =
new ASTPair();
3646 AST logicalOrExpression_AST =
null;
3649 astFactory.addASTChild(currentAST, returnAST);
3654 AST tmp158_AST =
null;
3655 tmp158_AST = astFactory.create(
LT(1));
3656 astFactory.makeASTRoot(currentAST, tmp158_AST);
3659 astFactory.addASTChild(currentAST, returnAST);
3667 logicalOrExpression_AST = (AST)currentAST.root;
3668 returnAST = logicalOrExpression_AST;
3674 ASTPair currentAST =
new ASTPair();
3675 AST logicalAndExpression_AST =
null;
3678 astFactory.addASTChild(currentAST, returnAST);
3682 if ((LA(1)==
LAND)) {
3683 AST tmp159_AST =
null;
3684 tmp159_AST = astFactory.create(
LT(1));
3685 astFactory.makeASTRoot(currentAST, tmp159_AST);
3688 astFactory.addASTChild(currentAST, returnAST);
3696 logicalAndExpression_AST = (AST)currentAST.root;
3697 returnAST = logicalAndExpression_AST;
3703 ASTPair currentAST =
new ASTPair();
3704 AST inclusiveOrExpression_AST =
null;
3707 astFactory.addASTChild(currentAST, returnAST);
3712 AST tmp160_AST =
null;
3713 tmp160_AST = astFactory.create(
LT(1));
3714 astFactory.makeASTRoot(currentAST, tmp160_AST);
3717 astFactory.addASTChild(currentAST, returnAST);
3725 inclusiveOrExpression_AST = (AST)currentAST.root;
3726 returnAST = inclusiveOrExpression_AST;
3732 ASTPair currentAST =
new ASTPair();
3733 AST exclusiveOrExpression_AST =
null;
3736 astFactory.addASTChild(currentAST, returnAST);
3740 if ((LA(1)==
BXOR)) {
3741 AST tmp161_AST =
null;
3742 tmp161_AST = astFactory.create(
LT(1));
3743 astFactory.makeASTRoot(currentAST, tmp161_AST);
3746 astFactory.addASTChild(currentAST, returnAST);
3754 exclusiveOrExpression_AST = (AST)currentAST.root;
3755 returnAST = exclusiveOrExpression_AST;
3758 public final void andExpression() throws RecognitionException, TokenStreamException {
3761 ASTPair currentAST =
new ASTPair();
3762 AST andExpression_AST =
null;
3765 astFactory.addASTChild(currentAST, returnAST);
3769 if ((LA(1)==
BAND)) {
3770 AST tmp162_AST =
null;
3771 tmp162_AST = astFactory.create(
LT(1));
3772 astFactory.makeASTRoot(currentAST, tmp162_AST);
3775 astFactory.addASTChild(currentAST, returnAST);
3783 andExpression_AST = (AST)currentAST.root;
3784 returnAST = andExpression_AST;
3790 ASTPair currentAST =
new ASTPair();
3791 AST equalityExpression_AST =
null;
3794 astFactory.addASTChild(currentAST, returnAST);
3803 AST tmp163_AST =
null;
3804 tmp163_AST = astFactory.create(
LT(1));
3805 astFactory.makeASTRoot(currentAST, tmp163_AST);
3811 AST tmp164_AST =
null;
3812 tmp164_AST = astFactory.create(
LT(1));
3813 astFactory.makeASTRoot(currentAST, tmp164_AST);
3819 throw new NoViableAltException(
LT(1), getFilename());
3824 astFactory.addASTChild(currentAST, returnAST);
3832 equalityExpression_AST = (AST)currentAST.root;
3833 returnAST = equalityExpression_AST;
3839 ASTPair currentAST =
new ASTPair();
3840 AST relationalExpression_AST =
null;
3843 astFactory.addASTChild(currentAST, returnAST);
3885 AST tmp165_AST =
null;
3886 tmp165_AST = astFactory.create(
LT(1));
3887 astFactory.makeASTRoot(currentAST, tmp165_AST);
3893 AST tmp166_AST =
null;
3894 tmp166_AST = astFactory.create(
LT(1));
3895 astFactory.makeASTRoot(currentAST, tmp166_AST);
3901 AST tmp167_AST =
null;
3902 tmp167_AST = astFactory.create(
LT(1));
3903 astFactory.makeASTRoot(currentAST, tmp167_AST);
3909 AST tmp168_AST =
null;
3910 tmp168_AST = astFactory.create(
LT(1));
3911 astFactory.makeASTRoot(currentAST, tmp168_AST);
3917 throw new NoViableAltException(
LT(1), getFilename());
3922 astFactory.addASTChild(currentAST, returnAST);
3934 AST tmp169_AST =
null;
3935 tmp169_AST = astFactory.create(
LT(1));
3936 astFactory.makeASTRoot(currentAST, tmp169_AST);
3939 astFactory.addASTChild(currentAST, returnAST);
3944 throw new NoViableAltException(
LT(1), getFilename());
3948 relationalExpression_AST = (AST)currentAST.root;
3949 returnAST = relationalExpression_AST;
3955 ASTPair currentAST =
new ASTPair();
3956 AST shiftExpression_AST =
null;
3959 astFactory.addASTChild(currentAST, returnAST);
3963 if (((LA(1) >=
SL && LA(1) <=
BSR))) {
3968 AST tmp170_AST =
null;
3969 tmp170_AST = astFactory.create(
LT(1));
3970 astFactory.makeASTRoot(currentAST, tmp170_AST);
3976 AST tmp171_AST =
null;
3977 tmp171_AST = astFactory.create(
LT(1));
3978 astFactory.makeASTRoot(currentAST, tmp171_AST);
3984 AST tmp172_AST =
null;
3985 tmp172_AST = astFactory.create(
LT(1));
3986 astFactory.makeASTRoot(currentAST, tmp172_AST);
3992 throw new NoViableAltException(
LT(1), getFilename());
3997 astFactory.addASTChild(currentAST, returnAST);
4005 shiftExpression_AST = (AST)currentAST.root;
4006 returnAST = shiftExpression_AST;
4012 ASTPair currentAST =
new ASTPair();
4013 AST additiveExpression_AST =
null;
4016 astFactory.addASTChild(currentAST, returnAST);
4025 AST tmp173_AST =
null;
4026 tmp173_AST = astFactory.create(
LT(1));
4027 astFactory.makeASTRoot(currentAST, tmp173_AST);
4033 AST tmp174_AST =
null;
4034 tmp174_AST = astFactory.create(
LT(1));
4035 astFactory.makeASTRoot(currentAST, tmp174_AST);
4041 throw new NoViableAltException(
LT(1), getFilename());
4046 astFactory.addASTChild(currentAST, returnAST);
4054 additiveExpression_AST = (AST)currentAST.root;
4055 returnAST = additiveExpression_AST;
4061 ASTPair currentAST =
new ASTPair();
4062 AST multiplicativeExpression_AST =
null;
4065 astFactory.addASTChild(currentAST, returnAST);
4074 AST tmp175_AST =
null;
4075 tmp175_AST = astFactory.create(
LT(1));
4076 astFactory.makeASTRoot(currentAST, tmp175_AST);
4082 AST tmp176_AST =
null;
4083 tmp176_AST = astFactory.create(
LT(1));
4084 astFactory.makeASTRoot(currentAST, tmp176_AST);
4090 AST tmp177_AST =
null;
4091 tmp177_AST = astFactory.create(
LT(1));
4092 astFactory.makeASTRoot(currentAST, tmp177_AST);
4098 throw new NoViableAltException(
LT(1), getFilename());
4103 astFactory.addASTChild(currentAST, returnAST);
4111 multiplicativeExpression_AST = (AST)currentAST.root;
4112 returnAST = multiplicativeExpression_AST;
4118 ASTPair currentAST =
new ASTPair();
4119 AST unaryExpression_AST =
null;
4124 AST tmp178_AST =
null;
4125 tmp178_AST = astFactory.create(
LT(1));
4126 astFactory.makeASTRoot(currentAST, tmp178_AST);
4129 astFactory.addASTChild(currentAST, returnAST);
4130 unaryExpression_AST = (AST)currentAST.root;
4135 AST tmp179_AST =
null;
4136 tmp179_AST = astFactory.create(
LT(1));
4137 astFactory.makeASTRoot(currentAST, tmp179_AST);
4140 astFactory.addASTChild(currentAST, returnAST);
4141 unaryExpression_AST = (AST)currentAST.root;
4146 AST tmp180_AST =
null;
4147 tmp180_AST = astFactory.create(
LT(1));
4148 astFactory.makeASTRoot(currentAST, tmp180_AST);
4150 if ( inputState.guessing==0 ) {
4154 astFactory.addASTChild(currentAST, returnAST);
4155 unaryExpression_AST = (AST)currentAST.root;
4160 AST tmp181_AST =
null;
4161 tmp181_AST = astFactory.create(
LT(1));
4162 astFactory.makeASTRoot(currentAST, tmp181_AST);
4164 if ( inputState.guessing==0 ) {
4168 astFactory.addASTChild(currentAST, returnAST);
4169 unaryExpression_AST = (AST)currentAST.root;
4199 astFactory.addASTChild(currentAST, returnAST);
4200 unaryExpression_AST = (AST)currentAST.root;
4205 throw new NoViableAltException(
LT(1), getFilename());
4208 returnAST = unaryExpression_AST;
4214 ASTPair currentAST =
new ASTPair();
4215 AST unaryExpressionNotPlusMinus_AST =
null;
4224 AST tmp182_AST =
null;
4225 tmp182_AST = astFactory.create(
LT(1));
4226 astFactory.makeASTRoot(currentAST, tmp182_AST);
4229 astFactory.addASTChild(currentAST, returnAST);
4230 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
4235 AST tmp183_AST =
null;
4236 tmp183_AST = astFactory.create(
LT(1));
4237 astFactory.makeASTRoot(currentAST, tmp183_AST);
4240 astFactory.addASTChild(currentAST, returnAST);
4241 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
4245 boolean synPredMatched180 =
false;
4248 synPredMatched180 =
true;
4249 inputState.guessing++;
4257 catch (RecognitionException pe) {
4258 synPredMatched180 =
false;
4261inputState.guessing--;
4263 if ( synPredMatched180 ) {
4265 lpb_AST = astFactory.create(lpb);
4266 astFactory.makeASTRoot(currentAST, lpb_AST);
4268 if ( inputState.guessing==0 ) {
4272 astFactory.addASTChild(currentAST, returnAST);
4275 astFactory.addASTChild(currentAST, returnAST);
4276 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
4279 boolean synPredMatched182 =
false;
4282 synPredMatched182 =
true;
4283 inputState.guessing++;
4292 catch (RecognitionException pe) {
4293 synPredMatched182 =
false;
4296inputState.guessing--;
4298 if ( synPredMatched182 ) {
4300 lp_AST = astFactory.create(lp);
4301 astFactory.makeASTRoot(currentAST, lp_AST);
4303 if ( inputState.guessing==0 ) {
4307 astFactory.addASTChild(currentAST, returnAST);
4310 astFactory.addASTChild(currentAST, returnAST);
4311 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
4315 astFactory.addASTChild(currentAST, returnAST);
4316 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
4319 throw new NoViableAltException(
LT(1), getFilename());
4322 returnAST = unaryExpressionNotPlusMinus_AST;
4328 ASTPair currentAST =
new ASTPair();
4329 AST postfixExpression_AST =
null;
4344 astFactory.addASTChild(currentAST, returnAST);
4348 if ((LA(1)==
DOT) && (LA(2)==
IDENT)) {
4349 AST tmp186_AST =
null;
4350 tmp186_AST = astFactory.create(
LT(1));
4351 astFactory.makeASTRoot(currentAST, tmp186_AST);
4353 AST tmp187_AST =
null;
4354 tmp187_AST = astFactory.create(
LT(1));
4355 astFactory.addASTChild(currentAST, tmp187_AST);
4362 lp_AST = astFactory.create(lp);
4363 astFactory.makeASTRoot(currentAST, lp_AST);
4365 if ( inputState.guessing==0 ) {
4369 astFactory.addASTChild(currentAST, returnAST);
4421 throw new NoViableAltException(
LT(1), getFilename());
4427 AST tmp189_AST =
null;
4428 tmp189_AST = astFactory.create(
LT(1));
4429 astFactory.makeASTRoot(currentAST, tmp189_AST);
4431 AST tmp190_AST =
null;
4432 tmp190_AST = astFactory.create(
LT(1));
4433 astFactory.addASTChild(currentAST, tmp190_AST);
4437 AST tmp191_AST =
null;
4438 tmp191_AST = astFactory.create(
LT(1));
4439 astFactory.makeASTRoot(currentAST, tmp191_AST);
4441 AST tmp192_AST =
null;
4442 tmp192_AST = astFactory.create(
LT(1));
4443 astFactory.addASTChild(currentAST, tmp192_AST);
4450 lp3_AST = astFactory.create(lp3);
4451 astFactory.makeASTRoot(currentAST, lp3_AST);
4454 astFactory.addASTChild(currentAST, returnAST);
4456 if ( inputState.guessing==0 ) {
4463 AST tmp194_AST =
null;
4464 tmp194_AST = astFactory.create(
LT(1));
4465 astFactory.makeASTRoot(currentAST, tmp194_AST);
4467 AST tmp195_AST =
null;
4468 tmp195_AST = astFactory.create(
LT(1));
4469 astFactory.addASTChild(currentAST, tmp195_AST);
4476 lps_AST = astFactory.create(lps);
4477 astFactory.makeASTRoot(currentAST, lps_AST);
4479 if ( inputState.guessing==0 ) {
4483 astFactory.addASTChild(currentAST, returnAST);
4535 throw new NoViableAltException(
LT(1), getFilename());
4543 throw new NoViableAltException(
LT(1), getFilename());
4549 AST tmp197_AST =
null;
4550 tmp197_AST = astFactory.create(
LT(1));
4551 astFactory.makeASTRoot(currentAST, tmp197_AST);
4554 astFactory.addASTChild(currentAST, returnAST);
4556 else if ((LA(1)==
LBRACK)) {
4558 lb_AST = astFactory.create(lb);
4559 astFactory.makeASTRoot(currentAST, lb_AST);
4561 if ( inputState.guessing==0 ) {
4565 astFactory.addASTChild(currentAST, returnAST);
4579 in_AST = astFactory.create(in);
4580 astFactory.makeASTRoot(currentAST, in_AST);
4582 if ( inputState.guessing==0 ) {
4590 de_AST = astFactory.create(de);
4591 astFactory.makeASTRoot(currentAST, de_AST);
4593 if ( inputState.guessing==0 ) {
4642 throw new NoViableAltException(
LT(1), getFilename());
4646 postfixExpression_AST = (AST)currentAST.root;
4647 returnAST = postfixExpression_AST;
4699 public final void newExpression() throws RecognitionException, TokenStreamException {
4702 ASTPair currentAST =
new ASTPair();
4703 AST newExpression_AST =
null;
4705 AST tmp199_AST =
null;
4706 tmp199_AST = astFactory.create(
LT(1));
4707 astFactory.makeASTRoot(currentAST, tmp199_AST);
4710 astFactory.addASTChild(currentAST, returnAST);
4717 astFactory.addASTChild(currentAST, returnAST);
4724 astFactory.addASTChild(currentAST, returnAST);
4775 throw new NoViableAltException(
LT(1), getFilename());
4784 astFactory.addASTChild(currentAST, returnAST);
4790 astFactory.addASTChild(currentAST, returnAST);
4841 throw new NoViableAltException(
LT(1), getFilename());
4849 throw new NoViableAltException(
LT(1), getFilename());
4853 newExpression_AST = (AST)currentAST.root;
4854 returnAST = newExpression_AST;
4857 public final void constant() throws RecognitionException, TokenStreamException {
4860 ASTPair currentAST =
new ASTPair();
4861 AST constant_AST =
null;
4866 AST tmp202_AST =
null;
4867 tmp202_AST = astFactory.create(
LT(1));
4868 astFactory.addASTChild(currentAST, tmp202_AST);
4870 constant_AST = (AST)currentAST.root;
4875 AST tmp203_AST =
null;
4876 tmp203_AST = astFactory.create(
LT(1));
4877 astFactory.addASTChild(currentAST, tmp203_AST);
4879 constant_AST = (AST)currentAST.root;
4884 AST tmp204_AST =
null;
4885 tmp204_AST = astFactory.create(
LT(1));
4886 astFactory.addASTChild(currentAST, tmp204_AST);
4888 constant_AST = (AST)currentAST.root;
4893 AST tmp205_AST =
null;
4894 tmp205_AST = astFactory.create(
LT(1));
4895 astFactory.addASTChild(currentAST, tmp205_AST);
4897 constant_AST = (AST)currentAST.root;
4902 AST tmp206_AST =
null;
4903 tmp206_AST = astFactory.create(
LT(1));
4904 astFactory.addASTChild(currentAST, tmp206_AST);
4906 constant_AST = (AST)currentAST.root;
4911 AST tmp207_AST =
null;
4912 tmp207_AST = astFactory.create(
LT(1));
4913 astFactory.addASTChild(currentAST, tmp207_AST);
4915 constant_AST = (AST)currentAST.root;
4920 throw new NoViableAltException(
LT(1), getFilename());
4923 returnAST = constant_AST;
4929 ASTPair currentAST =
new ASTPair();
4930 AST newArrayDeclarator_AST =
null;
4940 lb_AST = astFactory.create(lb);
4941 astFactory.makeASTRoot(currentAST, lb_AST);
4943 if ( inputState.guessing==0 ) {
4979 astFactory.addASTChild(currentAST, returnAST);
4988 throw new NoViableAltException(
LT(1), getFilename());
4995 if ( _cnt210>=1 ) {
break _loop210; }
else {
throw new NoViableAltException(
LT(1), getFilename());}
5001 newArrayDeclarator_AST = (AST)currentAST.root;
5002 returnAST = newArrayDeclarator_AST;
5010 "NULL_TREE_LOOKAHEAD",
5026 "IMPLEMENTS_CLAUSE",
5162 tokenTypeToASTClassMap=
null;
5165 private static final long[] mk_tokenSet_0() {
5166 long[] data = { 39032662786048L, 549755822076L, 0L, 0L};
5170 private static final long[] mk_tokenSet_1() {
5171 long[] data = { 109401406963714L, 549755822076L, 0L, 0L};
5175 private static final long[] mk_tokenSet_2() {
5176 long[] data = { 39032662786050L, 549755822076L, 0L, 0L};
5180 private static final long[] mk_tokenSet_3() {
5181 long[] data = { 3848290697216L, 2044L, 0L, 0L};
5185 private static final long[] mk_tokenSet_4() {
5186 long[] data = { -18010550218784768L, 549755822076L, 0L, 0L};
5190 private static final long[] mk_tokenSet_5() {
5191 long[] data = { -13366213103058944L, 549755953149L, 0L, 0L};
5195 private static final long[] mk_tokenSet_6() {
5196 long[] data = { -9218727699739049984L, 1L, 0L, 0L};
5200 private static final long[] mk_tokenSet_7() {
5201 long[] data = { 4538783999459328L, 2129920L, 0L, 0L};
5205 private static final long[] mk_tokenSet_8() {
5206 long[] data = { -17975365846695936L, -9223371401248215044L, 131065L, 0L, 0L, 0L};
5210 private static final long[] mk_tokenSet_9() {
5211 long[] data = { -9671854033731584L, -463894577153L, 131071L, 0L, 0L, 0L};
5215 private static final long[] mk_tokenSet_10() {
5216 long[] data = { -17975365846695936L, -9223371401248231428L, 131065L, 0L, 0L, 0L};
5220 private static final long[] mk_tokenSet_11() {
5221 long[] data = { -17975365846695936L, -9223371349675053060L, 131065L, 0L, 0L, 0L};
5225 private static final long[] mk_tokenSet_12() {
5226 long[] data = { -9671854033731584L, -4554753L, 131071L, 0L, 0L, 0L};
5230 private static final long[] mk_tokenSet_13() {
5231 long[] data = { -18010550218784768L, 549755815932L, 0L, 0L};
5235 private static final long[] mk_tokenSet_14() {
5236 long[] data = { -13366213103058944L, 549755815933L, 0L, 0L};
5240 private static final long[] mk_tokenSet_15() {
5241 long[] data = { -18014398509481984L, -9223372036853071872L, 131065L, 0L, 0L, 0L};
5245 private static final long[] mk_tokenSet_16() {
5246 long[] data = { -9675702324428800L, -1099507826685L, 131071L, 0L, 0L, 0L};
5250 private static final long[] mk_tokenSet_17() {
5251 long[] data = { 3848290697216L, 549755817980L, 0L, 0L};
5255 private static final long[] mk_tokenSet_18() {
5256 long[] data = { -18010550218784768L, 549755817980L, 0L, 0L};
5260 private static final long[] mk_tokenSet_19() {
5261 long[] data = { -18014398509481984L, -9223372036853063680L, 131065L, 0L, 0L, 0L};
5265 private static final long[] mk_tokenSet_20() {
5266 long[] data = { -9675702324428800L, -1099507793917L, 131071L, 0L, 0L, 0L};
5270 private static final long[] mk_tokenSet_21() {
5271 long[] data = { -18014398509481984L, -9223372036844683264L, 131065L, 0L, 0L, 0L};
5275 private static final long[] mk_tokenSet_22() {
5276 long[] data = { -18014398509481984L, 1703936L, 130944L, 0L, 0L, 0L};
5280 private static final long[] mk_tokenSet_23() {
5281 long[] data = { -13510798882111488L, -9223372036852809727L, 131065L, 0L, 0L, 0L};
5285 private static final long[] mk_tokenSet_24() {
5286 long[] data = { 4503599627370496L, 2228225L, 0L, 0L};
5290 private static final long[] mk_tokenSet_25() {
5291 long[] data = { 17345895439794176L, -1099500830717L, 31L, 0L, 0L, 0L};
5295 private static final long[] mk_tokenSet_26() {
5296 long[] data = { -664654778990592L, -412321120257L, 131071L, 0L, 0L, 0L};
5300 private static final long[] mk_tokenSet_27() {
5301 long[] data = { 2392537302040576L, 432345564227567616L, 0L, 0L};
5305 private static final long[] mk_tokenSet_28() {
5306 long[] data = { 0L, 2L, 6L, 0L, 0L, 0L};
5310 private static final long[] mk_tokenSet_29() {
5311 long[] data = { -668503069687808L, -1099499126781L, 131071L, 0L, 0L, 0L};
5315 private static final long[] mk_tokenSet_30() {
5316 long[] data = { -9007199254740992L, -9223372036853071872L, 131065L, 0L, 0L, 0L};
Set< String > getParsedEnumNames()
Returns the EnumTypes this HeaderParser processed.
static final BitSet _tokenSet_18
final void unaryExpression()
final void parameterModifier()
final void compoundStatement()
void buildTokenTypeASTClassMap()
final void throwsClause()
final void expressionList()
static final BitSet _tokenSet_8
final void logicalOrExpression()
Set< String > getParsedFunctionNames()
Returns the list of FunctionSymbols this HeaderParser has parsed.
static final BitSet _tokenSet_4
static final BitSet _tokenSet_17
final void interfaceExtends()
JavaParser(TokenBuffer tokenBuf)
static final BitSet _tokenSet_19
final void packageDefinition()
static final BitSet _tokenSet_0
static final BitSet _tokenSet_10
void clearParsedInnerInterfacesNames()
Clears the list of inner interfaces this HeaderParser has parsed.
static final BitSet _tokenSet_12
final void newExpression()
object instantiation.
static final BitSet _tokenSet_28
final void builtInTypeSpec(boolean addImagNode)
final void interfaceDefinition(AST antsBefore, AST modifiers, AST antsAfter)
JavaParser(ParserSharedInputState state)
final void arrayInitializer()
final void parameterDeclaration()
final void importDefinition()
final void andExpression()
final void multiplicativeExpression()
static final BitSet _tokenSet_14
final void classDefinition(AST antsBefore, AST modifiers, AST antsAfter)
final void typeSpec(boolean addImagNode)
static final BitSet _tokenSet_26
static final BitSet _tokenSet_16
void clearParsedInnerClassesNames()
Clears the list of inner classes this HeaderParser has parsed.
final void shiftExpression()
static final BitSet _tokenSet_3
static final BitSet _tokenSet_1
final void superClassClause()
final void finallyClause()
static final BitSet _tokenSet_9
final void inclusiveOrExpression()
static final BitSet _tokenSet_25
final void equalityExpression()
final void parameterDeclarationList()
final void declaratorBrackets(AST typ)
final void unaryExpressionNotPlusMinus()
final void explicitConstructorInvocation()
Catch obvious constructor calls, but not the expr.super(...) calls.
final void implementsClause()
final void conditionalExpression()
static final BitSet _tokenSet_2
final void constructorBody()
static final BitSet _tokenSet_15
final void variableDeclarator(AST antsBefore, AST mods, AST antsAfter, AST t)
Declaration of a variable.
final void identPrimary()
Match a, a.b.c refs, a.b.c(...) refs, a.b.c[], a.b.c[].class, and a.b.c.class refs.
void clearParsedEnumNames()
final void compilationUnit()
static final BitSet _tokenSet_23
final void declaration()
A declaration is the creation of a reference or primitive-type variable Create a separate Type/Var tr...
final void additiveExpression()
static final BitSet _tokenSet_22
final void identifierStar()
JavaParser(TokenBuffer tokenBuf, int k)
static final BitSet _tokenSet_6
static final BitSet _tokenSet_13
static final BitSet _tokenSet_11
final void exclusiveOrExpression()
static final BitSet _tokenSet_7
final void postfixExpression()
static final BitSet _tokenSet_30
static final BitSet _tokenSet_21
static final BitSet _tokenSet_27
final void primaryExpression()
static final String[] _tokenNames
final void relationalExpression()
static final BitSet _tokenSet_5
final void classTypeSpec(boolean addImagNode)
JavaParser(TokenStream lexer, int k)
final void typeDefinition()
JavaParser(TokenStream lexer)
Set< String > getParsedInnerClassesNames()
Returns the list of inner classes this HeaderParser has parsed.
static final BitSet _tokenSet_29
static final BitSet _tokenSet_20
Set< String > getParsedInnerInterfacesNames()
Returns the list of inner interfaces this HeaderParser has parsed.
final void newArrayDeclarator()
final void assignmentExpression()
final void variableDefinitions(AST antsBefore, AST mods, AST antsAfter, AST t)
final void logicalAndExpression()
static final BitSet _tokenSet_24
void clearParsedFunctionNames()
Clears the list of functions this HeaderParser has parsed.
final void varInitializer()