001// $ANTLR 2.7.7 (2006-11-01): "java.g" -> "GeneratedJavaRecognizer.java"$
002
003package com.puppycrawl.tools.checkstyle.grammars;
004
005import com.puppycrawl.tools.checkstyle.api.DetailAST;
006import java.text.MessageFormat;
007import antlr.CommonHiddenStreamToken;
008
009import antlr.TokenBuffer;
010import antlr.TokenStreamException;
011import antlr.TokenStreamIOException;
012import antlr.ANTLRException;
013import antlr.LLkParser;
014import antlr.Token;
015import antlr.TokenStream;
016import antlr.RecognitionException;
017import antlr.NoViableAltException;
018import antlr.MismatchedTokenException;
019import antlr.SemanticException;
020import antlr.ParserSharedInputState;
021import antlr.collections.impl.BitSet;
022import antlr.collections.AST;
023import java.util.Hashtable;
024import antlr.ASTFactory;
025import antlr.ASTPair;
026import antlr.collections.impl.ASTArray;
027
028/** Java 1.5 Recognizer
029 *
030 * This grammar is in the PUBLIC DOMAIN
031 */
032public class GeneratedJavaRecognizer extends antlr.LLkParser       implements GeneratedJavaTokenTypes
033 {
034
035    /**
036     * Counts the number of LT seen in the typeArguments production.
037     * It is used in semantic predicates to ensure we have seen
038     * enough closing '>' characters; which actually may have been
039     * either GT, SR or BSR tokens.
040     */
041    private int ltCounter = 0;
042
043    /**
044     * Counts the number of '>' characters that have been seen but
045     * have not yet been associated with the end of a typeParameters or
046     * typeArguments production. This is necessary because SR and BSR
047     * tokens have significance (the extra '>' characters) not only for the production
048     * that sees them but also productions higher in the stack (possibly right up to an outer-most
049     * typeParameters production). As the stack of the typeArguments/typeParameters productions unwind,
050     * any '>' characters seen prematurely through SRs or BSRs are reconciled.
051     */
052    private int gtToReconcile = 0;
053
054    /**
055     * The most recently seen gt sequence (GT, SR or BSR)
056     * encountered in any type argument or type parameter production.
057     * We retain this so we can keep manage the synthetic GT tokens/
058     * AST nodes we emit to have '<' & '>' balanced trees when encountering
059     * SR and BSR tokens.
060     */
061    private DetailAST currentGtSequence = null;
062
063    /**
064     * Consume a sequence of '>' characters (GT, SR or BSR)
065     * and match these against the '<' characters seen.
066     */
067    private void consumeCurrentGtSequence(DetailAST gtSequence)
068    {
069        currentGtSequence = gtSequence;
070        gtToReconcile += currentGtSequence.getText().length();
071        ltCounter -= currentGtSequence.getText().length();
072    }
073
074    /**
075     * Emits a single GT AST node with the line and column correctly
076     * set to its position in the source file. This must only
077     * ever be called when a typeParameters or typeArguments production
078     * is ending and there is at least one GT character to be emitted.
079     *
080     * @see #areThereGtsToEmit
081     */
082    private DetailAST emitSingleGt()
083    {
084        gtToReconcile -= 1;
085        CommonHiddenStreamToken gtToken = new CommonHiddenStreamToken(GENERIC_END, ">");
086        gtToken.setLine(currentGtSequence.getLineNo());
087        gtToken.setColumn(currentGtSequence.getColumnNo() + (currentGtSequence.getText().length() - gtToReconcile));
088        return (DetailAST)astFactory.create(gtToken);
089    }
090
091    /**
092     * @return true if there is at least one '>' seen but
093     * not reconciled with the end of a typeParameters or
094     * typeArguments production; returns false otherwise
095     */
096    private boolean areThereGtsToEmit()
097    {
098        return (gtToReconcile > 0);
099    }
100
101    /**
102     * @return true if there is exactly one '>' seen but
103     * not reconciled with the end of a typeParameters
104     * production; returns false otherwise
105     */
106    private boolean isThereASingleGtToEmit()
107    {
108        return (gtToReconcile == 1);
109    }
110
111    /**
112     * @return true if the '<' and '>' are evenly matched
113     * at the current typeParameters/typeArguments nested depth
114     */
115    private boolean areLtsAndGtsBalanced(int currentLtLevel)
116    {
117        return ((currentLtLevel != 0) || ltCounter == currentLtLevel);
118    }
119
120protected GeneratedJavaRecognizer(TokenBuffer tokenBuf, int k) {
121  super(tokenBuf,k);
122  tokenNames = _tokenNames;
123  buildTokenTypeASTClassMap();
124  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
125}
126
127public GeneratedJavaRecognizer(TokenBuffer tokenBuf) {
128  this(tokenBuf,2);
129}
130
131protected GeneratedJavaRecognizer(TokenStream lexer, int k) {
132  super(lexer,k);
133  tokenNames = _tokenNames;
134  buildTokenTypeASTClassMap();
135  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
136}
137
138public GeneratedJavaRecognizer(TokenStream lexer) {
139  this(lexer,2);
140}
141
142public GeneratedJavaRecognizer(ParserSharedInputState state) {
143  super(state,2);
144  tokenNames = _tokenNames;
145  buildTokenTypeASTClassMap();
146  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
147}
148
149        public final void compilationUnit() throws RecognitionException, TokenStreamException {
150                
151                returnAST = null;
152                ASTPair currentAST = new ASTPair();
153                AST compilationUnit_AST = null;
154                
155                {
156                boolean synPredMatched4 = false;
157                if (((LA(1)==LITERAL_package||LA(1)==AT) && (LA(2)==IDENT))) {
158                        int _m4 = mark();
159                        synPredMatched4 = true;
160                        inputState.guessing++;
161                        try {
162                                {
163                                annotations();
164                                match(LITERAL_package);
165                                }
166                        }
167                        catch (RecognitionException pe) {
168                                synPredMatched4 = false;
169                        }
170                        rewind(_m4);
171inputState.guessing--;
172                }
173                if ( synPredMatched4 ) {
174                        packageDefinition();
175                        astFactory.addASTChild(currentAST, returnAST);
176                }
177                else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
178                }
179                else {
180                        throw new NoViableAltException(LT(1), getFilename());
181                }
182                
183                }
184                {
185                _loop6:
186                do {
187                        if ((LA(1)==SEMI||LA(1)==LITERAL_import) && (_tokenSet_1.member(LA(2)))) {
188                                importDefinition();
189                                astFactory.addASTChild(currentAST, returnAST);
190                        }
191                        else {
192                                break _loop6;
193                        }
194                        
195                } while (true);
196                }
197                {
198                _loop8:
199                do {
200                        if ((_tokenSet_2.member(LA(1)))) {
201                                typeDefinition();
202                                astFactory.addASTChild(currentAST, returnAST);
203                        }
204                        else {
205                                break _loop8;
206                        }
207                        
208                } while (true);
209                }
210                match(Token.EOF_TYPE);
211                compilationUnit_AST = (AST)currentAST.root;
212                returnAST = compilationUnit_AST;
213        }
214        
215        public final void annotations() throws RecognitionException, TokenStreamException {
216                
217                returnAST = null;
218                ASTPair currentAST = new ASTPair();
219                AST annotations_AST = null;
220                
221                {
222                _loop68:
223                do {
224                        if ((LA(1)==AT) && (LA(2)==IDENT)) {
225                                annotation();
226                                astFactory.addASTChild(currentAST, returnAST);
227                        }
228                        else {
229                                break _loop68;
230                        }
231                        
232                } while (true);
233                }
234                if ( inputState.guessing==0 ) {
235                        annotations_AST = (AST)currentAST.root;
236                        annotations_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ANNOTATIONS,"ANNOTATIONS")).add(annotations_AST));
237                        currentAST.root = annotations_AST;
238                        currentAST.child = annotations_AST!=null &&annotations_AST.getFirstChild()!=null ?
239                                annotations_AST.getFirstChild() : annotations_AST;
240                        currentAST.advanceChildToEnd();
241                }
242                annotations_AST = (AST)currentAST.root;
243                returnAST = annotations_AST;
244        }
245        
246        public final void packageDefinition() throws RecognitionException, TokenStreamException {
247                
248                returnAST = null;
249                ASTPair currentAST = new ASTPair();
250                AST packageDefinition_AST = null;
251                Token  p = null;
252                AST p_AST = null;
253                
254                try {      // for error handling
255                        annotations();
256                        astFactory.addASTChild(currentAST, returnAST);
257                        p = LT(1);
258                        p_AST = astFactory.create(p);
259                        astFactory.makeASTRoot(currentAST, p_AST);
260                        match(LITERAL_package);
261                        if ( inputState.guessing==0 ) {
262                                p_AST.setType(PACKAGE_DEF);
263                        }
264                        identifier();
265                        astFactory.addASTChild(currentAST, returnAST);
266                        AST tmp2_AST = null;
267                        tmp2_AST = astFactory.create(LT(1));
268                        astFactory.addASTChild(currentAST, tmp2_AST);
269                        match(SEMI);
270                        packageDefinition_AST = (AST)currentAST.root;
271                }
272                catch (RecognitionException ex) {
273                        if (inputState.guessing==0) {
274                                reportError(ex);
275                                recover(ex,_tokenSet_0);
276                        } else {
277                          throw ex;
278                        }
279                }
280                returnAST = packageDefinition_AST;
281        }
282        
283        public final void importDefinition() throws RecognitionException, TokenStreamException {
284                
285                returnAST = null;
286                ASTPair currentAST = new ASTPair();
287                AST importDefinition_AST = null;
288                Token  i = null;
289                AST i_AST = null;
290                
291                try {      // for error handling
292                        switch ( LA(1)) {
293                        case LITERAL_import:
294                        {
295                                i = LT(1);
296                                i_AST = astFactory.create(i);
297                                astFactory.makeASTRoot(currentAST, i_AST);
298                                match(LITERAL_import);
299                                if ( inputState.guessing==0 ) {
300                                        i_AST.setType(IMPORT);
301                                }
302                                {
303                                switch ( LA(1)) {
304                                case LITERAL_static:
305                                {
306                                        AST tmp3_AST = null;
307                                        tmp3_AST = astFactory.create(LT(1));
308                                        astFactory.addASTChild(currentAST, tmp3_AST);
309                                        match(LITERAL_static);
310                                        if ( inputState.guessing==0 ) {
311                                                i_AST.setType(STATIC_IMPORT);
312                                        }
313                                        break;
314                                }
315                                case IDENT:
316                                {
317                                        break;
318                                }
319                                default:
320                                {
321                                        throw new NoViableAltException(LT(1), getFilename());
322                                }
323                                }
324                                }
325                                identifierStar();
326                                astFactory.addASTChild(currentAST, returnAST);
327                                AST tmp4_AST = null;
328                                tmp4_AST = astFactory.create(LT(1));
329                                astFactory.addASTChild(currentAST, tmp4_AST);
330                                match(SEMI);
331                                importDefinition_AST = (AST)currentAST.root;
332                                break;
333                        }
334                        case SEMI:
335                        {
336                                AST tmp5_AST = null;
337                                tmp5_AST = astFactory.create(LT(1));
338                                astFactory.addASTChild(currentAST, tmp5_AST);
339                                match(SEMI);
340                                importDefinition_AST = (AST)currentAST.root;
341                                break;
342                        }
343                        default:
344                        {
345                                throw new NoViableAltException(LT(1), getFilename());
346                        }
347                        }
348                }
349                catch (RecognitionException ex) {
350                        if (inputState.guessing==0) {
351                                reportError(ex);
352                                recover(ex,_tokenSet_0);
353                        } else {
354                          throw ex;
355                        }
356                }
357                returnAST = importDefinition_AST;
358        }
359        
360        public final void typeDefinition() throws RecognitionException, TokenStreamException {
361                
362                returnAST = null;
363                ASTPair currentAST = new ASTPair();
364                AST typeDefinition_AST = null;
365                AST m_AST = null;
366                
367                try {      // for error handling
368                        switch ( LA(1)) {
369                        case FINAL:
370                        case ABSTRACT:
371                        case STRICTFP:
372                        case LITERAL_private:
373                        case LITERAL_public:
374                        case LITERAL_protected:
375                        case LITERAL_static:
376                        case LITERAL_transient:
377                        case LITERAL_native:
378                        case LITERAL_synchronized:
379                        case LITERAL_volatile:
380                        case LITERAL_class:
381                        case LITERAL_interface:
382                        case LITERAL_default:
383                        case ENUM:
384                        case AT:
385                        {
386                                modifiers();
387                                m_AST = (AST)returnAST;
388                                typeDefinitionInternal(m_AST);
389                                astFactory.addASTChild(currentAST, returnAST);
390                                typeDefinition_AST = (AST)currentAST.root;
391                                break;
392                        }
393                        case SEMI:
394                        {
395                                AST tmp6_AST = null;
396                                tmp6_AST = astFactory.create(LT(1));
397                                astFactory.addASTChild(currentAST, tmp6_AST);
398                                match(SEMI);
399                                typeDefinition_AST = (AST)currentAST.root;
400                                break;
401                        }
402                        default:
403                        {
404                                throw new NoViableAltException(LT(1), getFilename());
405                        }
406                        }
407                }
408                catch (RecognitionException ex) {
409                        if (inputState.guessing==0) {
410                                reportError(ex);
411                                recover(ex,_tokenSet_3);
412                        } else {
413                          throw ex;
414                        }
415                }
416                returnAST = typeDefinition_AST;
417        }
418        
419        public final void identifier() throws RecognitionException, TokenStreamException {
420                
421                returnAST = null;
422                ASTPair currentAST = new ASTPair();
423                AST identifier_AST = null;
424                
425                AST tmp7_AST = null;
426                tmp7_AST = astFactory.create(LT(1));
427                astFactory.addASTChild(currentAST, tmp7_AST);
428                match(IDENT);
429                {
430                _loop54:
431                do {
432                        if ((LA(1)==DOT) && (LA(2)==IDENT)) {
433                                AST tmp8_AST = null;
434                                tmp8_AST = astFactory.create(LT(1));
435                                astFactory.makeASTRoot(currentAST, tmp8_AST);
436                                match(DOT);
437                                AST tmp9_AST = null;
438                                tmp9_AST = astFactory.create(LT(1));
439                                astFactory.addASTChild(currentAST, tmp9_AST);
440                                match(IDENT);
441                        }
442                        else {
443                                break _loop54;
444                        }
445                        
446                } while (true);
447                }
448                identifier_AST = (AST)currentAST.root;
449                returnAST = identifier_AST;
450        }
451        
452        public final void identifierStar() throws RecognitionException, TokenStreamException {
453                
454                returnAST = null;
455                ASTPair currentAST = new ASTPair();
456                AST identifierStar_AST = null;
457                
458                AST tmp10_AST = null;
459                tmp10_AST = astFactory.create(LT(1));
460                astFactory.addASTChild(currentAST, tmp10_AST);
461                match(IDENT);
462                {
463                _loop57:
464                do {
465                        if ((LA(1)==DOT) && (LA(2)==IDENT)) {
466                                AST tmp11_AST = null;
467                                tmp11_AST = astFactory.create(LT(1));
468                                astFactory.makeASTRoot(currentAST, tmp11_AST);
469                                match(DOT);
470                                AST tmp12_AST = null;
471                                tmp12_AST = astFactory.create(LT(1));
472                                astFactory.addASTChild(currentAST, tmp12_AST);
473                                match(IDENT);
474                        }
475                        else {
476                                break _loop57;
477                        }
478                        
479                } while (true);
480                }
481                {
482                switch ( LA(1)) {
483                case DOT:
484                {
485                        AST tmp13_AST = null;
486                        tmp13_AST = astFactory.create(LT(1));
487                        astFactory.makeASTRoot(currentAST, tmp13_AST);
488                        match(DOT);
489                        AST tmp14_AST = null;
490                        tmp14_AST = astFactory.create(LT(1));
491                        astFactory.addASTChild(currentAST, tmp14_AST);
492                        match(STAR);
493                        break;
494                }
495                case SEMI:
496                {
497                        break;
498                }
499                default:
500                {
501                        throw new NoViableAltException(LT(1), getFilename());
502                }
503                }
504                }
505                identifierStar_AST = (AST)currentAST.root;
506                returnAST = identifierStar_AST;
507        }
508        
509        public final void modifiers() throws RecognitionException, TokenStreamException {
510                
511                returnAST = null;
512                ASTPair currentAST = new ASTPair();
513                AST modifiers_AST = null;
514                
515                {
516                _loop61:
517                do {
518                        if ((_tokenSet_4.member(LA(1)))) {
519                                modifier();
520                                astFactory.addASTChild(currentAST, returnAST);
521                        }
522                        else if (((LA(1)==AT) && (LA(2)==IDENT))&&(LA(1)==AT && !LT(2).getText().equals("interface"))) {
523                                annotation();
524                                astFactory.addASTChild(currentAST, returnAST);
525                        }
526                        else {
527                                break _loop61;
528                        }
529                        
530                } while (true);
531                }
532                if ( inputState.guessing==0 ) {
533                        modifiers_AST = (AST)currentAST.root;
534                        modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(modifiers_AST));
535                        currentAST.root = modifiers_AST;
536                        currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ?
537                                modifiers_AST.getFirstChild() : modifiers_AST;
538                        currentAST.advanceChildToEnd();
539                }
540                modifiers_AST = (AST)currentAST.root;
541                returnAST = modifiers_AST;
542        }
543        
544        protected final void typeDefinitionInternal(
545                AST modifiers
546        ) throws RecognitionException, TokenStreamException {
547                
548                returnAST = null;
549                ASTPair currentAST = new ASTPair();
550                AST typeDefinitionInternal_AST = null;
551                
552                switch ( LA(1)) {
553                case LITERAL_class:
554                {
555                        classDefinition(modifiers);
556                        astFactory.addASTChild(currentAST, returnAST);
557                        typeDefinitionInternal_AST = (AST)currentAST.root;
558                        break;
559                }
560                case LITERAL_interface:
561                {
562                        interfaceDefinition(modifiers);
563                        astFactory.addASTChild(currentAST, returnAST);
564                        typeDefinitionInternal_AST = (AST)currentAST.root;
565                        break;
566                }
567                case ENUM:
568                {
569                        enumDefinition(modifiers);
570                        astFactory.addASTChild(currentAST, returnAST);
571                        typeDefinitionInternal_AST = (AST)currentAST.root;
572                        break;
573                }
574                case AT:
575                {
576                        annotationDefinition(modifiers);
577                        astFactory.addASTChild(currentAST, returnAST);
578                        typeDefinitionInternal_AST = (AST)currentAST.root;
579                        break;
580                }
581                default:
582                {
583                        throw new NoViableAltException(LT(1), getFilename());
584                }
585                }
586                returnAST = typeDefinitionInternal_AST;
587        }
588        
589        public final void classDefinition(
590                AST modifiers
591        ) throws RecognitionException, TokenStreamException {
592                
593                returnAST = null;
594                ASTPair currentAST = new ASTPair();
595                AST classDefinition_AST = null;
596                Token  c = null;
597                AST c_AST = null;
598                AST tp_AST = null;
599                AST sc_AST = null;
600                AST ic_AST = null;
601                AST cb_AST = null;
602                
603                c = LT(1);
604                c_AST = astFactory.create(c);
605                match(LITERAL_class);
606                AST tmp15_AST = null;
607                tmp15_AST = astFactory.create(LT(1));
608                match(IDENT);
609                {
610                switch ( LA(1)) {
611                case LT:
612                {
613                        typeParameters();
614                        tp_AST = (AST)returnAST;
615                        break;
616                }
617                case LITERAL_extends:
618                case LCURLY:
619                case LITERAL_implements:
620                {
621                        break;
622                }
623                default:
624                {
625                        throw new NoViableAltException(LT(1), getFilename());
626                }
627                }
628                }
629                superClassClause();
630                sc_AST = (AST)returnAST;
631                implementsClause();
632                ic_AST = (AST)returnAST;
633                classBlock();
634                cb_AST = (AST)returnAST;
635                if ( inputState.guessing==0 ) {
636                        classDefinition_AST = (AST)currentAST.root;
637                        classDefinition_AST = (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(CLASS_DEF,"CLASS_DEF")).add(modifiers).add(c_AST).add(tmp15_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(cb_AST));
638                        currentAST.root = classDefinition_AST;
639                        currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ?
640                                classDefinition_AST.getFirstChild() : classDefinition_AST;
641                        currentAST.advanceChildToEnd();
642                }
643                returnAST = classDefinition_AST;
644        }
645        
646        public final void interfaceDefinition(
647                AST modifiers
648        ) throws RecognitionException, TokenStreamException {
649                
650                returnAST = null;
651                ASTPair currentAST = new ASTPair();
652                AST interfaceDefinition_AST = null;
653                Token  i = null;
654                AST i_AST = null;
655                AST tp_AST = null;
656                AST ie_AST = null;
657                AST cb_AST = null;
658                
659                i = LT(1);
660                i_AST = astFactory.create(i);
661                match(LITERAL_interface);
662                AST tmp16_AST = null;
663                tmp16_AST = astFactory.create(LT(1));
664                match(IDENT);
665                {
666                switch ( LA(1)) {
667                case LT:
668                {
669                        typeParameters();
670                        tp_AST = (AST)returnAST;
671                        break;
672                }
673                case LITERAL_extends:
674                case LCURLY:
675                {
676                        break;
677                }
678                default:
679                {
680                        throw new NoViableAltException(LT(1), getFilename());
681                }
682                }
683                }
684                interfaceExtends();
685                ie_AST = (AST)returnAST;
686                classBlock();
687                cb_AST = (AST)returnAST;
688                if ( inputState.guessing==0 ) {
689                        interfaceDefinition_AST = (AST)currentAST.root;
690                        interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(INTERFACE_DEF,"INTERFACE_DEF")).add(modifiers).add(i_AST).add(tmp16_AST).add(tp_AST).add(ie_AST).add(cb_AST));
691                        currentAST.root = interfaceDefinition_AST;
692                        currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ?
693                                interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST;
694                        currentAST.advanceChildToEnd();
695                }
696                returnAST = interfaceDefinition_AST;
697        }
698        
699        public final void enumDefinition(
700                AST modifiers
701        ) throws RecognitionException, TokenStreamException {
702                
703                returnAST = null;
704                ASTPair currentAST = new ASTPair();
705                AST enumDefinition_AST = null;
706                Token  e = null;
707                AST e_AST = null;
708                AST ic_AST = null;
709                AST eb_AST = null;
710                
711                e = LT(1);
712                e_AST = astFactory.create(e);
713                match(ENUM);
714                AST tmp17_AST = null;
715                tmp17_AST = astFactory.create(LT(1));
716                match(IDENT);
717                implementsClause();
718                ic_AST = (AST)returnAST;
719                enumBlock();
720                eb_AST = (AST)returnAST;
721                if ( inputState.guessing==0 ) {
722                        enumDefinition_AST = (AST)currentAST.root;
723                        enumDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ENUM_DEF,"ENUM_DEF")).add(modifiers).add(e_AST).add(tmp17_AST).add(ic_AST).add(eb_AST));
724                        currentAST.root = enumDefinition_AST;
725                        currentAST.child = enumDefinition_AST!=null &&enumDefinition_AST.getFirstChild()!=null ?
726                                enumDefinition_AST.getFirstChild() : enumDefinition_AST;
727                        currentAST.advanceChildToEnd();
728                }
729                returnAST = enumDefinition_AST;
730        }
731        
732        public final void annotationDefinition(
733                AST modifiers
734        ) throws RecognitionException, TokenStreamException {
735                
736                returnAST = null;
737                ASTPair currentAST = new ASTPair();
738                AST annotationDefinition_AST = null;
739                Token  a = null;
740                AST a_AST = null;
741                Token  i = null;
742                AST i_AST = null;
743                AST ab_AST = null;
744                
745                a = LT(1);
746                a_AST = astFactory.create(a);
747                match(AT);
748                i = LT(1);
749                i_AST = astFactory.create(i);
750                match(LITERAL_interface);
751                AST tmp18_AST = null;
752                tmp18_AST = astFactory.create(LT(1));
753                match(IDENT);
754                annotationBlock();
755                ab_AST = (AST)returnAST;
756                if ( inputState.guessing==0 ) {
757                        annotationDefinition_AST = (AST)currentAST.root;
758                        annotationDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ANNOTATION_DEF,"ANNOTATION_DEF")).add(modifiers).add(a_AST).add(i_AST).add(tmp18_AST).add(ab_AST));
759                        currentAST.root = annotationDefinition_AST;
760                        currentAST.child = annotationDefinition_AST!=null &&annotationDefinition_AST.getFirstChild()!=null ?
761                                annotationDefinition_AST.getFirstChild() : annotationDefinition_AST;
762                        currentAST.advanceChildToEnd();
763                }
764                returnAST = annotationDefinition_AST;
765        }
766        
767        public final void typeSpec(
768                boolean addImagNode
769        ) throws RecognitionException, TokenStreamException {
770                
771                returnAST = null;
772                ASTPair currentAST = new ASTPair();
773                AST typeSpec_AST = null;
774                
775                switch ( LA(1)) {
776                case IDENT:
777                case AT:
778                {
779                        classTypeSpec(addImagNode);
780                        astFactory.addASTChild(currentAST, returnAST);
781                        typeSpec_AST = (AST)currentAST.root;
782                        break;
783                }
784                case LITERAL_void:
785                case LITERAL_boolean:
786                case LITERAL_byte:
787                case LITERAL_char:
788                case LITERAL_short:
789                case LITERAL_int:
790                case LITERAL_float:
791                case LITERAL_long:
792                case LITERAL_double:
793                {
794                        builtInTypeSpec(addImagNode);
795                        astFactory.addASTChild(currentAST, returnAST);
796                        typeSpec_AST = (AST)currentAST.root;
797                        break;
798                }
799                default:
800                {
801                        throw new NoViableAltException(LT(1), getFilename());
802                }
803                }
804                returnAST = typeSpec_AST;
805        }
806        
807        public final void classTypeSpec(
808                boolean addImagNode
809        ) throws RecognitionException, TokenStreamException {
810                
811                returnAST = null;
812                ASTPair currentAST = new ASTPair();
813                AST classTypeSpec_AST = null;
814                Token  lb = null;
815                AST lb_AST = null;
816                
817                classOrInterfaceType(addImagNode);
818                astFactory.addASTChild(currentAST, returnAST);
819                {
820                _loop17:
821                do {
822                        if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
823                                lb = LT(1);
824                                lb_AST = astFactory.create(lb);
825                                astFactory.makeASTRoot(currentAST, lb_AST);
826                                match(LBRACK);
827                                if ( inputState.guessing==0 ) {
828                                        lb_AST.setType(ARRAY_DECLARATOR);
829                                }
830                                AST tmp19_AST = null;
831                                tmp19_AST = astFactory.create(LT(1));
832                                astFactory.addASTChild(currentAST, tmp19_AST);
833                                match(RBRACK);
834                        }
835                        else {
836                                break _loop17;
837                        }
838                        
839                } while (true);
840                }
841                if ( inputState.guessing==0 ) {
842                        classTypeSpec_AST = (AST)currentAST.root;
843                        
844                        if ( addImagNode ) {
845                        classTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(classTypeSpec_AST));
846                        }
847                        
848                        currentAST.root = classTypeSpec_AST;
849                        currentAST.child = classTypeSpec_AST!=null &&classTypeSpec_AST.getFirstChild()!=null ?
850                                classTypeSpec_AST.getFirstChild() : classTypeSpec_AST;
851                        currentAST.advanceChildToEnd();
852                }
853                classTypeSpec_AST = (AST)currentAST.root;
854                returnAST = classTypeSpec_AST;
855        }
856        
857        public final void builtInTypeSpec(
858                boolean addImagNode
859        ) throws RecognitionException, TokenStreamException {
860                
861                returnAST = null;
862                ASTPair currentAST = new ASTPair();
863                AST builtInTypeSpec_AST = null;
864                Token  lb = null;
865                AST lb_AST = null;
866                
867                builtInType();
868                astFactory.addASTChild(currentAST, returnAST);
869                {
870                _loop48:
871                do {
872                        if ((LA(1)==LBRACK)) {
873                                lb = LT(1);
874                                lb_AST = astFactory.create(lb);
875                                astFactory.makeASTRoot(currentAST, lb_AST);
876                                match(LBRACK);
877                                if ( inputState.guessing==0 ) {
878                                        lb_AST.setType(ARRAY_DECLARATOR);
879                                }
880                                AST tmp20_AST = null;
881                                tmp20_AST = astFactory.create(LT(1));
882                                astFactory.addASTChild(currentAST, tmp20_AST);
883                                match(RBRACK);
884                        }
885                        else {
886                                break _loop48;
887                        }
888                        
889                } while (true);
890                }
891                if ( inputState.guessing==0 ) {
892                        builtInTypeSpec_AST = (AST)currentAST.root;
893                        
894                        if ( addImagNode ) {
895                        builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(builtInTypeSpec_AST));
896                        }
897                        
898                        currentAST.root = builtInTypeSpec_AST;
899                        currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ?
900                                builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST;
901                        currentAST.advanceChildToEnd();
902                }
903                builtInTypeSpec_AST = (AST)currentAST.root;
904                returnAST = builtInTypeSpec_AST;
905        }
906        
907        public final void classOrInterfaceType(
908                boolean addImagNode
909        ) throws RecognitionException, TokenStreamException {
910                
911                returnAST = null;
912                ASTPair currentAST = new ASTPair();
913                AST classOrInterfaceType_AST = null;
914                
915                {
916                if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) {
917                        annotations();
918                        astFactory.addASTChild(currentAST, returnAST);
919                }
920                else if ((LA(1)==IDENT) && (_tokenSet_5.member(LA(2)))) {
921                }
922                else {
923                        throw new NoViableAltException(LT(1), getFilename());
924                }
925                
926                }
927                AST tmp21_AST = null;
928                tmp21_AST = astFactory.create(LT(1));
929                astFactory.addASTChild(currentAST, tmp21_AST);
930                match(IDENT);
931                {
932                if ((LA(1)==LT) && (_tokenSet_5.member(LA(2)))) {
933                        typeArguments(addImagNode);
934                        astFactory.addASTChild(currentAST, returnAST);
935                }
936                else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
937                }
938                else {
939                        throw new NoViableAltException(LT(1), getFilename());
940                }
941                
942                }
943                {
944                _loop23:
945                do {
946                        if ((LA(1)==DOT) && (LA(2)==IDENT)) {
947                                AST tmp22_AST = null;
948                                tmp22_AST = astFactory.create(LT(1));
949                                astFactory.makeASTRoot(currentAST, tmp22_AST);
950                                match(DOT);
951                                AST tmp23_AST = null;
952                                tmp23_AST = astFactory.create(LT(1));
953                                astFactory.addASTChild(currentAST, tmp23_AST);
954                                match(IDENT);
955                                {
956                                if ((LA(1)==LT) && (_tokenSet_5.member(LA(2)))) {
957                                        typeArguments(addImagNode);
958                                        astFactory.addASTChild(currentAST, returnAST);
959                                }
960                                else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
961                                }
962                                else {
963                                        throw new NoViableAltException(LT(1), getFilename());
964                                }
965                                
966                                }
967                        }
968                        else {
969                                break _loop23;
970                        }
971                        
972                } while (true);
973                }
974                classOrInterfaceType_AST = (AST)currentAST.root;
975                returnAST = classOrInterfaceType_AST;
976        }
977        
978        public final void typeArguments(
979                boolean addImagNode
980        ) throws RecognitionException, TokenStreamException {
981                
982                returnAST = null;
983                ASTPair currentAST = new ASTPair();
984                AST typeArguments_AST = null;
985                Token  lt = null;
986                AST lt_AST = null;
987                int currentLtLevel = 0;
988                
989                if ( inputState.guessing==0 ) {
990                        currentLtLevel = ltCounter;
991                }
992                lt = LT(1);
993                lt_AST = astFactory.create(lt);
994                astFactory.addASTChild(currentAST, lt_AST);
995                match(LT);
996                if ( inputState.guessing==0 ) {
997                        lt_AST.setType(GENERIC_START); ;ltCounter++;
998                }
999                {
1000                if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
1001                        typeArgument(addImagNode);
1002                        astFactory.addASTChild(currentAST, returnAST);
1003                        {
1004                        _loop35:
1005                        do {
1006                                if (((LA(1)==COMMA) && (_tokenSet_7.member(LA(2))))&&(gtToReconcile == 0)) {
1007                                        AST tmp24_AST = null;
1008                                        tmp24_AST = astFactory.create(LT(1));
1009                                        astFactory.addASTChild(currentAST, tmp24_AST);
1010                                        match(COMMA);
1011                                        typeArgument(addImagNode);
1012                                        astFactory.addASTChild(currentAST, returnAST);
1013                                }
1014                                else {
1015                                        break _loop35;
1016                                }
1017                                
1018                        } while (true);
1019                        }
1020                }
1021                else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
1022                }
1023                else {
1024                        throw new NoViableAltException(LT(1), getFilename());
1025                }
1026                
1027                }
1028                {
1029                if ((_tokenSet_8.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
1030                        typeArgumentsOrParametersEnd();
1031                        astFactory.addASTChild(currentAST, returnAST);
1032                }
1033                else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
1034                }
1035                else {
1036                        throw new NoViableAltException(LT(1), getFilename());
1037                }
1038                
1039                }
1040                if ( inputState.guessing==0 ) {
1041                        
1042                        if (areThereGtsToEmit())
1043                        {
1044                        astFactory.addASTChild(currentAST, emitSingleGt());
1045                        }
1046                        
1047                }
1048                if (!(areLtsAndGtsBalanced(currentLtLevel)))
1049                  throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)");
1050                if ( inputState.guessing==0 ) {
1051                        typeArguments_AST = (AST)currentAST.root;
1052                        typeArguments_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS")).add(typeArguments_AST));
1053                        currentAST.root = typeArguments_AST;
1054                        currentAST.child = typeArguments_AST!=null &&typeArguments_AST.getFirstChild()!=null ?
1055                                typeArguments_AST.getFirstChild() : typeArguments_AST;
1056                        currentAST.advanceChildToEnd();
1057                }
1058                typeArguments_AST = (AST)currentAST.root;
1059                returnAST = typeArguments_AST;
1060        }
1061        
1062        public final void typeArgument(
1063                boolean addImagNode
1064        ) throws RecognitionException, TokenStreamException {
1065                
1066                returnAST = null;
1067                ASTPair currentAST = new ASTPair();
1068                AST typeArgument_AST = null;
1069                
1070                {
1071                {
1072                if (((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) {
1073                        annotations();
1074                        astFactory.addASTChild(currentAST, returnAST);
1075                }
1076                else if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
1077                }
1078                else {
1079                        throw new NoViableAltException(LT(1), getFilename());
1080                }
1081                
1082                }
1083                {
1084                switch ( LA(1)) {
1085                case IDENT:
1086                case AT:
1087                {
1088                        classTypeSpec(addImagNode);
1089                        astFactory.addASTChild(currentAST, returnAST);
1090                        break;
1091                }
1092                case LITERAL_void:
1093                case LITERAL_boolean:
1094                case LITERAL_byte:
1095                case LITERAL_char:
1096                case LITERAL_short:
1097                case LITERAL_int:
1098                case LITERAL_float:
1099                case LITERAL_long:
1100                case LITERAL_double:
1101                {
1102                        builtInTypeArraySpec(addImagNode);
1103                        astFactory.addASTChild(currentAST, returnAST);
1104                        break;
1105                }
1106                case QUESTION:
1107                {
1108                        wildcardType(addImagNode);
1109                        astFactory.addASTChild(currentAST, returnAST);
1110                        break;
1111                }
1112                default:
1113                {
1114                        throw new NoViableAltException(LT(1), getFilename());
1115                }
1116                }
1117                }
1118                }
1119                if ( inputState.guessing==0 ) {
1120                        typeArgument_AST = (AST)currentAST.root;
1121                        typeArgument_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENT,"TYPE_ARGUMENT")).add(typeArgument_AST));
1122                        currentAST.root = typeArgument_AST;
1123                        currentAST.child = typeArgument_AST!=null &&typeArgument_AST.getFirstChild()!=null ?
1124                                typeArgument_AST.getFirstChild() : typeArgument_AST;
1125                        currentAST.advanceChildToEnd();
1126                }
1127                typeArgument_AST = (AST)currentAST.root;
1128                returnAST = typeArgument_AST;
1129        }
1130        
1131        public final void builtInTypeArraySpec(
1132                boolean addImagNode
1133        ) throws RecognitionException, TokenStreamException {
1134                
1135                returnAST = null;
1136                ASTPair currentAST = new ASTPair();
1137                AST builtInTypeArraySpec_AST = null;
1138                Token  lb = null;
1139                AST lb_AST = null;
1140                
1141                builtInType();
1142                astFactory.addASTChild(currentAST, returnAST);
1143                {
1144                int _cnt45=0;
1145                _loop45:
1146                do {
1147                        if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
1148                                lb = LT(1);
1149                                lb_AST = astFactory.create(lb);
1150                                astFactory.makeASTRoot(currentAST, lb_AST);
1151                                match(LBRACK);
1152                                if ( inputState.guessing==0 ) {
1153                                        lb_AST.setType(ARRAY_DECLARATOR);
1154                                }
1155                                AST tmp25_AST = null;
1156                                tmp25_AST = astFactory.create(LT(1));
1157                                astFactory.addASTChild(currentAST, tmp25_AST);
1158                                match(RBRACK);
1159                        }
1160                        else {
1161                                if ( _cnt45>=1 ) { break _loop45; } else {throw new NoViableAltException(LT(1), getFilename());}
1162                        }
1163                        
1164                        _cnt45++;
1165                } while (true);
1166                }
1167                if ( inputState.guessing==0 ) {
1168                        builtInTypeArraySpec_AST = (AST)currentAST.root;
1169                        
1170                        if ( addImagNode ) {
1171                        builtInTypeArraySpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(builtInTypeArraySpec_AST));
1172                        }
1173                        
1174                        currentAST.root = builtInTypeArraySpec_AST;
1175                        currentAST.child = builtInTypeArraySpec_AST!=null &&builtInTypeArraySpec_AST.getFirstChild()!=null ?
1176                                builtInTypeArraySpec_AST.getFirstChild() : builtInTypeArraySpec_AST;
1177                        currentAST.advanceChildToEnd();
1178                }
1179                builtInTypeArraySpec_AST = (AST)currentAST.root;
1180                returnAST = builtInTypeArraySpec_AST;
1181        }
1182        
1183        public final void wildcardType(
1184                boolean addImagNode
1185        ) throws RecognitionException, TokenStreamException {
1186                
1187                returnAST = null;
1188                ASTPair currentAST = new ASTPair();
1189                AST wildcardType_AST = null;
1190                Token  q = null;
1191                AST q_AST = null;
1192                
1193                q = LT(1);
1194                q_AST = astFactory.create(q);
1195                astFactory.addASTChild(currentAST, q_AST);
1196                match(QUESTION);
1197                if ( inputState.guessing==0 ) {
1198                        q_AST.setType(WILDCARD_TYPE);
1199                }
1200                {
1201                boolean synPredMatched31 = false;
1202                if (((LA(1)==LITERAL_extends||LA(1)==LITERAL_super) && (_tokenSet_9.member(LA(2))))) {
1203                        int _m31 = mark();
1204                        synPredMatched31 = true;
1205                        inputState.guessing++;
1206                        try {
1207                                {
1208                                switch ( LA(1)) {
1209                                case LITERAL_extends:
1210                                {
1211                                        match(LITERAL_extends);
1212                                        break;
1213                                }
1214                                case LITERAL_super:
1215                                {
1216                                        match(LITERAL_super);
1217                                        break;
1218                                }
1219                                default:
1220                                {
1221                                        throw new NoViableAltException(LT(1), getFilename());
1222                                }
1223                                }
1224                                }
1225                        }
1226                        catch (RecognitionException pe) {
1227                                synPredMatched31 = false;
1228                        }
1229                        rewind(_m31);
1230inputState.guessing--;
1231                }
1232                if ( synPredMatched31 ) {
1233                        typeArgumentBounds(addImagNode);
1234                        astFactory.addASTChild(currentAST, returnAST);
1235                }
1236                else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
1237                }
1238                else {
1239                        throw new NoViableAltException(LT(1), getFilename());
1240                }
1241                
1242                }
1243                wildcardType_AST = (AST)currentAST.root;
1244                returnAST = wildcardType_AST;
1245        }
1246        
1247        public final void typeArgumentBounds(
1248                boolean addImagNode
1249        ) throws RecognitionException, TokenStreamException {
1250                
1251                returnAST = null;
1252                ASTPair currentAST = new ASTPair();
1253                AST typeArgumentBounds_AST = null;
1254                Token  e = null;
1255                AST e_AST = null;
1256                Token  s = null;
1257                AST s_AST = null;
1258                Token  lb = null;
1259                AST lb_AST = null;
1260                
1261                {
1262                switch ( LA(1)) {
1263                case LITERAL_extends:
1264                {
1265                        e = LT(1);
1266                        e_AST = astFactory.create(e);
1267                        astFactory.makeASTRoot(currentAST, e_AST);
1268                        match(LITERAL_extends);
1269                        if ( inputState.guessing==0 ) {
1270                                e_AST.setType(TYPE_UPPER_BOUNDS);
1271                        }
1272                        break;
1273                }
1274                case LITERAL_super:
1275                {
1276                        s = LT(1);
1277                        s_AST = astFactory.create(s);
1278                        astFactory.makeASTRoot(currentAST, s_AST);
1279                        match(LITERAL_super);
1280                        if ( inputState.guessing==0 ) {
1281                                s_AST.setType(TYPE_LOWER_BOUNDS);
1282                        }
1283                        break;
1284                }
1285                default:
1286                {
1287                        throw new NoViableAltException(LT(1), getFilename());
1288                }
1289                }
1290                }
1291                {
1292                switch ( LA(1)) {
1293                case IDENT:
1294                case AT:
1295                {
1296                        classOrInterfaceType(addImagNode);
1297                        astFactory.addASTChild(currentAST, returnAST);
1298                        break;
1299                }
1300                case LITERAL_void:
1301                case LITERAL_boolean:
1302                case LITERAL_byte:
1303                case LITERAL_char:
1304                case LITERAL_short:
1305                case LITERAL_int:
1306                case LITERAL_float:
1307                case LITERAL_long:
1308                case LITERAL_double:
1309                {
1310                        builtInType();
1311                        astFactory.addASTChild(currentAST, returnAST);
1312                        break;
1313                }
1314                default:
1315                {
1316                        throw new NoViableAltException(LT(1), getFilename());
1317                }
1318                }
1319                }
1320                {
1321                _loop42:
1322                do {
1323                        if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
1324                                lb = LT(1);
1325                                lb_AST = astFactory.create(lb);
1326                                astFactory.makeASTRoot(currentAST, lb_AST);
1327                                match(LBRACK);
1328                                if ( inputState.guessing==0 ) {
1329                                        lb_AST.setType(ARRAY_DECLARATOR);
1330                                }
1331                                AST tmp26_AST = null;
1332                                tmp26_AST = astFactory.create(LT(1));
1333                                astFactory.addASTChild(currentAST, tmp26_AST);
1334                                match(RBRACK);
1335                        }
1336                        else {
1337                                break _loop42;
1338                        }
1339                        
1340                } while (true);
1341                }
1342                typeArgumentBounds_AST = (AST)currentAST.root;
1343                returnAST = typeArgumentBounds_AST;
1344        }
1345        
1346        protected final void typeArgumentsOrParametersEnd() throws RecognitionException, TokenStreamException {
1347                
1348                returnAST = null;
1349                ASTPair currentAST = new ASTPair();
1350                AST typeArgumentsOrParametersEnd_AST = null;
1351                Token  g = null;
1352                AST g_AST = null;
1353                Token  sr = null;
1354                AST sr_AST = null;
1355                Token  bsr = null;
1356                AST bsr_AST = null;
1357                
1358                switch ( LA(1)) {
1359                case GT:
1360                {
1361                        g = LT(1);
1362                        g_AST = astFactory.create(g);
1363                        match(GT);
1364                        if ( inputState.guessing==0 ) {
1365                                consumeCurrentGtSequence((DetailAST)g_AST);
1366                        }
1367                        break;
1368                }
1369                case SR:
1370                {
1371                        sr = LT(1);
1372                        sr_AST = astFactory.create(sr);
1373                        match(SR);
1374                        if ( inputState.guessing==0 ) {
1375                                consumeCurrentGtSequence((DetailAST)sr_AST);
1376                        }
1377                        break;
1378                }
1379                case BSR:
1380                {
1381                        bsr = LT(1);
1382                        bsr_AST = astFactory.create(bsr);
1383                        match(BSR);
1384                        if ( inputState.guessing==0 ) {
1385                                consumeCurrentGtSequence((DetailAST)bsr_AST);
1386                        }
1387                        break;
1388                }
1389                default:
1390                {
1391                        throw new NoViableAltException(LT(1), getFilename());
1392                }
1393                }
1394                returnAST = typeArgumentsOrParametersEnd_AST;
1395        }
1396        
1397        public final void builtInType() throws RecognitionException, TokenStreamException {
1398                
1399                returnAST = null;
1400                ASTPair currentAST = new ASTPair();
1401                AST builtInType_AST = null;
1402                
1403                switch ( LA(1)) {
1404                case LITERAL_void:
1405                {
1406                        AST tmp27_AST = null;
1407                        tmp27_AST = astFactory.create(LT(1));
1408                        astFactory.addASTChild(currentAST, tmp27_AST);
1409                        match(LITERAL_void);
1410                        builtInType_AST = (AST)currentAST.root;
1411                        break;
1412                }
1413                case LITERAL_boolean:
1414                {
1415                        AST tmp28_AST = null;
1416                        tmp28_AST = astFactory.create(LT(1));
1417                        astFactory.addASTChild(currentAST, tmp28_AST);
1418                        match(LITERAL_boolean);
1419                        builtInType_AST = (AST)currentAST.root;
1420                        break;
1421                }
1422                case LITERAL_byte:
1423                {
1424                        AST tmp29_AST = null;
1425                        tmp29_AST = astFactory.create(LT(1));
1426                        astFactory.addASTChild(currentAST, tmp29_AST);
1427                        match(LITERAL_byte);
1428                        builtInType_AST = (AST)currentAST.root;
1429                        break;
1430                }
1431                case LITERAL_char:
1432                {
1433                        AST tmp30_AST = null;
1434                        tmp30_AST = astFactory.create(LT(1));
1435                        astFactory.addASTChild(currentAST, tmp30_AST);
1436                        match(LITERAL_char);
1437                        builtInType_AST = (AST)currentAST.root;
1438                        break;
1439                }
1440                case LITERAL_short:
1441                {
1442                        AST tmp31_AST = null;
1443                        tmp31_AST = astFactory.create(LT(1));
1444                        astFactory.addASTChild(currentAST, tmp31_AST);
1445                        match(LITERAL_short);
1446                        builtInType_AST = (AST)currentAST.root;
1447                        break;
1448                }
1449                case LITERAL_int:
1450                {
1451                        AST tmp32_AST = null;
1452                        tmp32_AST = astFactory.create(LT(1));
1453                        astFactory.addASTChild(currentAST, tmp32_AST);
1454                        match(LITERAL_int);
1455                        builtInType_AST = (AST)currentAST.root;
1456                        break;
1457                }
1458                case LITERAL_float:
1459                {
1460                        AST tmp33_AST = null;
1461                        tmp33_AST = astFactory.create(LT(1));
1462                        astFactory.addASTChild(currentAST, tmp33_AST);
1463                        match(LITERAL_float);
1464                        builtInType_AST = (AST)currentAST.root;
1465                        break;
1466                }
1467                case LITERAL_long:
1468                {
1469                        AST tmp34_AST = null;
1470                        tmp34_AST = astFactory.create(LT(1));
1471                        astFactory.addASTChild(currentAST, tmp34_AST);
1472                        match(LITERAL_long);
1473                        builtInType_AST = (AST)currentAST.root;
1474                        break;
1475                }
1476                case LITERAL_double:
1477                {
1478                        AST tmp35_AST = null;
1479                        tmp35_AST = astFactory.create(LT(1));
1480                        astFactory.addASTChild(currentAST, tmp35_AST);
1481                        match(LITERAL_double);
1482                        builtInType_AST = (AST)currentAST.root;
1483                        break;
1484                }
1485                default:
1486                {
1487                        throw new NoViableAltException(LT(1), getFilename());
1488                }
1489                }
1490                returnAST = builtInType_AST;
1491        }
1492        
1493        public final void type() throws RecognitionException, TokenStreamException {
1494                
1495                returnAST = null;
1496                ASTPair currentAST = new ASTPair();
1497                AST type_AST = null;
1498                
1499                switch ( LA(1)) {
1500                case IDENT:
1501                case AT:
1502                {
1503                        classOrInterfaceType(false);
1504                        astFactory.addASTChild(currentAST, returnAST);
1505                        type_AST = (AST)currentAST.root;
1506                        break;
1507                }
1508                case LITERAL_void:
1509                case LITERAL_boolean:
1510                case LITERAL_byte:
1511                case LITERAL_char:
1512                case LITERAL_short:
1513                case LITERAL_int:
1514                case LITERAL_float:
1515                case LITERAL_long:
1516                case LITERAL_double:
1517                {
1518                        builtInType();
1519                        astFactory.addASTChild(currentAST, returnAST);
1520                        type_AST = (AST)currentAST.root;
1521                        break;
1522                }
1523                default:
1524                {
1525                        throw new NoViableAltException(LT(1), getFilename());
1526                }
1527                }
1528                returnAST = type_AST;
1529        }
1530        
1531/** A declaration is the creation of a reference or primitive-type variable
1532 *  Create a separate Type/Var tree for each var in the var list.
1533    @throws RecognitionException if recognition problem occurs.
1534    @throws TokenStreamException if problem occurs while generating a stream of tokens.
1535 */
1536        public final void declaration() throws RecognitionException, TokenStreamException {
1537                
1538                returnAST = null;
1539                ASTPair currentAST = new ASTPair();
1540                AST declaration_AST = null;
1541                AST m_AST = null;
1542                AST t_AST = null;
1543                AST v_AST = null;
1544                
1545                modifiers();
1546                m_AST = (AST)returnAST;
1547                typeSpec(false);
1548                t_AST = (AST)returnAST;
1549                variableDefinitions(m_AST,t_AST);
1550                v_AST = (AST)returnAST;
1551                if ( inputState.guessing==0 ) {
1552                        declaration_AST = (AST)currentAST.root;
1553                        declaration_AST = v_AST;
1554                        currentAST.root = declaration_AST;
1555                        currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
1556                                declaration_AST.getFirstChild() : declaration_AST;
1557                        currentAST.advanceChildToEnd();
1558                }
1559                returnAST = declaration_AST;
1560        }
1561        
1562        public final void variableDefinitions(
1563                AST mods, AST t
1564        ) throws RecognitionException, TokenStreamException {
1565                
1566                returnAST = null;
1567                ASTPair currentAST = new ASTPair();
1568                AST variableDefinitions_AST = null;
1569                
1570                variableDeclarator((AST) getASTFactory().dupTree(mods),
1571                           (AST) getASTFactory().dupList(t));
1572                astFactory.addASTChild(currentAST, returnAST);
1573                {
1574                _loop160:
1575                do {
1576                        if ((LA(1)==COMMA)) {
1577                                AST tmp36_AST = null;
1578                                tmp36_AST = astFactory.create(LT(1));
1579                                astFactory.addASTChild(currentAST, tmp36_AST);
1580                                match(COMMA);
1581                                variableDeclarator((AST) getASTFactory().dupTree(mods),
1582                               (AST) getASTFactory().dupList(t));
1583                                astFactory.addASTChild(currentAST, returnAST);
1584                        }
1585                        else {
1586                                break _loop160;
1587                        }
1588                        
1589                } while (true);
1590                }
1591                variableDefinitions_AST = (AST)currentAST.root;
1592                returnAST = variableDefinitions_AST;
1593        }
1594        
1595        public final void modifier() throws RecognitionException, TokenStreamException {
1596                
1597                returnAST = null;
1598                ASTPair currentAST = new ASTPair();
1599                AST modifier_AST = null;
1600                
1601                switch ( LA(1)) {
1602                case LITERAL_private:
1603                {
1604                        AST tmp37_AST = null;
1605                        tmp37_AST = astFactory.create(LT(1));
1606                        astFactory.addASTChild(currentAST, tmp37_AST);
1607                        match(LITERAL_private);
1608                        modifier_AST = (AST)currentAST.root;
1609                        break;
1610                }
1611                case LITERAL_public:
1612                {
1613                        AST tmp38_AST = null;
1614                        tmp38_AST = astFactory.create(LT(1));
1615                        astFactory.addASTChild(currentAST, tmp38_AST);
1616                        match(LITERAL_public);
1617                        modifier_AST = (AST)currentAST.root;
1618                        break;
1619                }
1620                case LITERAL_protected:
1621                {
1622                        AST tmp39_AST = null;
1623                        tmp39_AST = astFactory.create(LT(1));
1624                        astFactory.addASTChild(currentAST, tmp39_AST);
1625                        match(LITERAL_protected);
1626                        modifier_AST = (AST)currentAST.root;
1627                        break;
1628                }
1629                case LITERAL_static:
1630                {
1631                        AST tmp40_AST = null;
1632                        tmp40_AST = astFactory.create(LT(1));
1633                        astFactory.addASTChild(currentAST, tmp40_AST);
1634                        match(LITERAL_static);
1635                        modifier_AST = (AST)currentAST.root;
1636                        break;
1637                }
1638                case LITERAL_transient:
1639                {
1640                        AST tmp41_AST = null;
1641                        tmp41_AST = astFactory.create(LT(1));
1642                        astFactory.addASTChild(currentAST, tmp41_AST);
1643                        match(LITERAL_transient);
1644                        modifier_AST = (AST)currentAST.root;
1645                        break;
1646                }
1647                case FINAL:
1648                {
1649                        AST tmp42_AST = null;
1650                        tmp42_AST = astFactory.create(LT(1));
1651                        astFactory.addASTChild(currentAST, tmp42_AST);
1652                        match(FINAL);
1653                        modifier_AST = (AST)currentAST.root;
1654                        break;
1655                }
1656                case ABSTRACT:
1657                {
1658                        AST tmp43_AST = null;
1659                        tmp43_AST = astFactory.create(LT(1));
1660                        astFactory.addASTChild(currentAST, tmp43_AST);
1661                        match(ABSTRACT);
1662                        modifier_AST = (AST)currentAST.root;
1663                        break;
1664                }
1665                case LITERAL_native:
1666                {
1667                        AST tmp44_AST = null;
1668                        tmp44_AST = astFactory.create(LT(1));
1669                        astFactory.addASTChild(currentAST, tmp44_AST);
1670                        match(LITERAL_native);
1671                        modifier_AST = (AST)currentAST.root;
1672                        break;
1673                }
1674                case LITERAL_synchronized:
1675                {
1676                        AST tmp45_AST = null;
1677                        tmp45_AST = astFactory.create(LT(1));
1678                        astFactory.addASTChild(currentAST, tmp45_AST);
1679                        match(LITERAL_synchronized);
1680                        modifier_AST = (AST)currentAST.root;
1681                        break;
1682                }
1683                case LITERAL_volatile:
1684                {
1685                        AST tmp46_AST = null;
1686                        tmp46_AST = astFactory.create(LT(1));
1687                        astFactory.addASTChild(currentAST, tmp46_AST);
1688                        match(LITERAL_volatile);
1689                        modifier_AST = (AST)currentAST.root;
1690                        break;
1691                }
1692                case STRICTFP:
1693                {
1694                        AST tmp47_AST = null;
1695                        tmp47_AST = astFactory.create(LT(1));
1696                        astFactory.addASTChild(currentAST, tmp47_AST);
1697                        match(STRICTFP);
1698                        modifier_AST = (AST)currentAST.root;
1699                        break;
1700                }
1701                case LITERAL_default:
1702                {
1703                        AST tmp48_AST = null;
1704                        tmp48_AST = astFactory.create(LT(1));
1705                        astFactory.addASTChild(currentAST, tmp48_AST);
1706                        match(LITERAL_default);
1707                        modifier_AST = (AST)currentAST.root;
1708                        break;
1709                }
1710                default:
1711                {
1712                        throw new NoViableAltException(LT(1), getFilename());
1713                }
1714                }
1715                returnAST = modifier_AST;
1716        }
1717        
1718        public final void annotation() throws RecognitionException, TokenStreamException {
1719                
1720                returnAST = null;
1721                ASTPair currentAST = new ASTPair();
1722                AST annotation_AST = null;
1723                AST i_AST = null;
1724                Token  l = null;
1725                AST l_AST = null;
1726                AST args_AST = null;
1727                Token  r = null;
1728                AST r_AST = null;
1729                
1730                AST tmp49_AST = null;
1731                tmp49_AST = astFactory.create(LT(1));
1732                match(AT);
1733                identifier();
1734                i_AST = (AST)returnAST;
1735                {
1736                if ((LA(1)==LPAREN) && (_tokenSet_10.member(LA(2)))) {
1737                        l = LT(1);
1738                        l_AST = astFactory.create(l);
1739                        match(LPAREN);
1740                        {
1741                        switch ( LA(1)) {
1742                        case LITERAL_void:
1743                        case LITERAL_boolean:
1744                        case LITERAL_byte:
1745                        case LITERAL_char:
1746                        case LITERAL_short:
1747                        case LITERAL_int:
1748                        case LITERAL_float:
1749                        case LITERAL_long:
1750                        case LITERAL_double:
1751                        case IDENT:
1752                        case LCURLY:
1753                        case LPAREN:
1754                        case LITERAL_this:
1755                        case LITERAL_super:
1756                        case PLUS:
1757                        case MINUS:
1758                        case INC:
1759                        case DEC:
1760                        case BNOT:
1761                        case LNOT:
1762                        case LITERAL_true:
1763                        case LITERAL_false:
1764                        case LITERAL_null:
1765                        case LITERAL_new:
1766                        case NUM_INT:
1767                        case CHAR_LITERAL:
1768                        case STRING_LITERAL:
1769                        case NUM_FLOAT:
1770                        case NUM_LONG:
1771                        case NUM_DOUBLE:
1772                        case AT:
1773                        {
1774                                annotationArguments();
1775                                args_AST = (AST)returnAST;
1776                                break;
1777                        }
1778                        case RPAREN:
1779                        {
1780                                break;
1781                        }
1782                        default:
1783                        {
1784                                throw new NoViableAltException(LT(1), getFilename());
1785                        }
1786                        }
1787                        }
1788                        r = LT(1);
1789                        r_AST = astFactory.create(r);
1790                        match(RPAREN);
1791                }
1792                else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
1793                }
1794                else {
1795                        throw new NoViableAltException(LT(1), getFilename());
1796                }
1797                
1798                }
1799                if ( inputState.guessing==0 ) {
1800                        annotation_AST = (AST)currentAST.root;
1801                        annotation_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ANNOTATION,"ANNOTATION")).add(tmp49_AST).add(i_AST).add(l_AST).add(args_AST).add(r_AST));
1802                        currentAST.root = annotation_AST;
1803                        currentAST.child = annotation_AST!=null &&annotation_AST.getFirstChild()!=null ?
1804                                annotation_AST.getFirstChild() : annotation_AST;
1805                        currentAST.advanceChildToEnd();
1806                }
1807                returnAST = annotation_AST;
1808        }
1809        
1810        public final void annotationArguments() throws RecognitionException, TokenStreamException {
1811                
1812                returnAST = null;
1813                ASTPair currentAST = new ASTPair();
1814                AST annotationArguments_AST = null;
1815                
1816                if ((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
1817                        annotationMemberValueInitializer();
1818                        astFactory.addASTChild(currentAST, returnAST);
1819                        annotationArguments_AST = (AST)currentAST.root;
1820                }
1821                else if ((LA(1)==IDENT) && (LA(2)==ASSIGN)) {
1822                        annotationMemberValuePairs();
1823                        astFactory.addASTChild(currentAST, returnAST);
1824                        annotationArguments_AST = (AST)currentAST.root;
1825                }
1826                else {
1827                        throw new NoViableAltException(LT(1), getFilename());
1828                }
1829                
1830                returnAST = annotationArguments_AST;
1831        }
1832        
1833        public final void annotationMemberValueInitializer() throws RecognitionException, TokenStreamException {
1834                
1835                returnAST = null;
1836                ASTPair currentAST = new ASTPair();
1837                AST annotationMemberValueInitializer_AST = null;
1838                
1839                switch ( LA(1)) {
1840                case LITERAL_void:
1841                case LITERAL_boolean:
1842                case LITERAL_byte:
1843                case LITERAL_char:
1844                case LITERAL_short:
1845                case LITERAL_int:
1846                case LITERAL_float:
1847                case LITERAL_long:
1848                case LITERAL_double:
1849                case IDENT:
1850                case LPAREN:
1851                case LITERAL_this:
1852                case LITERAL_super:
1853                case PLUS:
1854                case MINUS:
1855                case INC:
1856                case DEC:
1857                case BNOT:
1858                case LNOT:
1859                case LITERAL_true:
1860                case LITERAL_false:
1861                case LITERAL_null:
1862                case LITERAL_new:
1863                case NUM_INT:
1864                case CHAR_LITERAL:
1865                case STRING_LITERAL:
1866                case NUM_FLOAT:
1867                case NUM_LONG:
1868                case NUM_DOUBLE:
1869                {
1870                        annotationExpression();
1871                        astFactory.addASTChild(currentAST, returnAST);
1872                        annotationMemberValueInitializer_AST = (AST)currentAST.root;
1873                        break;
1874                }
1875                case AT:
1876                {
1877                        annotation();
1878                        astFactory.addASTChild(currentAST, returnAST);
1879                        annotationMemberValueInitializer_AST = (AST)currentAST.root;
1880                        break;
1881                }
1882                case LCURLY:
1883                {
1884                        annotationMemberArrayInitializer();
1885                        astFactory.addASTChild(currentAST, returnAST);
1886                        annotationMemberValueInitializer_AST = (AST)currentAST.root;
1887                        break;
1888                }
1889                default:
1890                {
1891                        throw new NoViableAltException(LT(1), getFilename());
1892                }
1893                }
1894                returnAST = annotationMemberValueInitializer_AST;
1895        }
1896        
1897        public final void annotationMemberValuePairs() throws RecognitionException, TokenStreamException {
1898                
1899                returnAST = null;
1900                ASTPair currentAST = new ASTPair();
1901                AST annotationMemberValuePairs_AST = null;
1902                
1903                annotationMemberValuePair();
1904                astFactory.addASTChild(currentAST, returnAST);
1905                {
1906                _loop72:
1907                do {
1908                        if ((LA(1)==COMMA)) {
1909                                AST tmp50_AST = null;
1910                                tmp50_AST = astFactory.create(LT(1));
1911                                astFactory.addASTChild(currentAST, tmp50_AST);
1912                                match(COMMA);
1913                                annotationMemberValuePair();
1914                                astFactory.addASTChild(currentAST, returnAST);
1915                        }
1916                        else {
1917                                break _loop72;
1918                        }
1919                        
1920                } while (true);
1921                }
1922                annotationMemberValuePairs_AST = (AST)currentAST.root;
1923                returnAST = annotationMemberValuePairs_AST;
1924        }
1925        
1926        public final void annotationMemberValuePair() throws RecognitionException, TokenStreamException {
1927                
1928                returnAST = null;
1929                ASTPair currentAST = new ASTPair();
1930                AST annotationMemberValuePair_AST = null;
1931                Token  i = null;
1932                AST i_AST = null;
1933                Token  a = null;
1934                AST a_AST = null;
1935                AST v_AST = null;
1936                
1937                i = LT(1);
1938                i_AST = astFactory.create(i);
1939                match(IDENT);
1940                a = LT(1);
1941                a_AST = astFactory.create(a);
1942                match(ASSIGN);
1943                annotationMemberValueInitializer();
1944                v_AST = (AST)returnAST;
1945                if ( inputState.guessing==0 ) {
1946                        annotationMemberValuePair_AST = (AST)currentAST.root;
1947                        annotationMemberValuePair_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR")).add(i_AST).add(a_AST).add(v_AST));
1948                        currentAST.root = annotationMemberValuePair_AST;
1949                        currentAST.child = annotationMemberValuePair_AST!=null &&annotationMemberValuePair_AST.getFirstChild()!=null ?
1950                                annotationMemberValuePair_AST.getFirstChild() : annotationMemberValuePair_AST;
1951                        currentAST.advanceChildToEnd();
1952                }
1953                returnAST = annotationMemberValuePair_AST;
1954        }
1955        
1956        public final void annotationExpression() throws RecognitionException, TokenStreamException {
1957                
1958                returnAST = null;
1959                ASTPair currentAST = new ASTPair();
1960                AST annotationExpression_AST = null;
1961                
1962                conditionalExpression();
1963                astFactory.addASTChild(currentAST, returnAST);
1964                if ( inputState.guessing==0 ) {
1965                        annotationExpression_AST = (AST)currentAST.root;
1966                        annotationExpression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(annotationExpression_AST));
1967                        currentAST.root = annotationExpression_AST;
1968                        currentAST.child = annotationExpression_AST!=null &&annotationExpression_AST.getFirstChild()!=null ?
1969                                annotationExpression_AST.getFirstChild() : annotationExpression_AST;
1970                        currentAST.advanceChildToEnd();
1971                }
1972                annotationExpression_AST = (AST)currentAST.root;
1973                returnAST = annotationExpression_AST;
1974        }
1975        
1976        public final void annotationMemberArrayInitializer() throws RecognitionException, TokenStreamException {
1977                
1978                returnAST = null;
1979                ASTPair currentAST = new ASTPair();
1980                AST annotationMemberArrayInitializer_AST = null;
1981                Token  lc = null;
1982                AST lc_AST = null;
1983                
1984                lc = LT(1);
1985                lc_AST = astFactory.create(lc);
1986                astFactory.makeASTRoot(currentAST, lc_AST);
1987                match(LCURLY);
1988                if ( inputState.guessing==0 ) {
1989                        lc_AST.setType(ANNOTATION_ARRAY_INIT);
1990                }
1991                {
1992                switch ( LA(1)) {
1993                case LITERAL_void:
1994                case LITERAL_boolean:
1995                case LITERAL_byte:
1996                case LITERAL_char:
1997                case LITERAL_short:
1998                case LITERAL_int:
1999                case LITERAL_float:
2000                case LITERAL_long:
2001                case LITERAL_double:
2002                case IDENT:
2003                case LPAREN:
2004                case LITERAL_this:
2005                case LITERAL_super:
2006                case PLUS:
2007                case MINUS:
2008                case INC:
2009                case DEC:
2010                case BNOT:
2011                case LNOT:
2012                case LITERAL_true:
2013                case LITERAL_false:
2014                case LITERAL_null:
2015                case LITERAL_new:
2016                case NUM_INT:
2017                case CHAR_LITERAL:
2018                case STRING_LITERAL:
2019                case NUM_FLOAT:
2020                case NUM_LONG:
2021                case NUM_DOUBLE:
2022                case AT:
2023                {
2024                        annotationMemberArrayValueInitializer();
2025                        astFactory.addASTChild(currentAST, returnAST);
2026                        {
2027                        _loop78:
2028                        do {
2029                                if ((LA(1)==COMMA) && (_tokenSet_14.member(LA(2)))) {
2030                                        AST tmp51_AST = null;
2031                                        tmp51_AST = astFactory.create(LT(1));
2032                                        astFactory.addASTChild(currentAST, tmp51_AST);
2033                                        match(COMMA);
2034                                        annotationMemberArrayValueInitializer();
2035                                        astFactory.addASTChild(currentAST, returnAST);
2036                                }
2037                                else {
2038                                        break _loop78;
2039                                }
2040                                
2041                        } while (true);
2042                        }
2043                        {
2044                        switch ( LA(1)) {
2045                        case COMMA:
2046                        {
2047                                AST tmp52_AST = null;
2048                                tmp52_AST = astFactory.create(LT(1));
2049                                astFactory.addASTChild(currentAST, tmp52_AST);
2050                                match(COMMA);
2051                                break;
2052                        }
2053                        case RCURLY:
2054                        {
2055                                break;
2056                        }
2057                        default:
2058                        {
2059                                throw new NoViableAltException(LT(1), getFilename());
2060                        }
2061                        }
2062                        }
2063                        break;
2064                }
2065                case RCURLY:
2066                {
2067                        break;
2068                }
2069                default:
2070                {
2071                        throw new NoViableAltException(LT(1), getFilename());
2072                }
2073                }
2074                }
2075                AST tmp53_AST = null;
2076                tmp53_AST = astFactory.create(LT(1));
2077                astFactory.addASTChild(currentAST, tmp53_AST);
2078                match(RCURLY);
2079                annotationMemberArrayInitializer_AST = (AST)currentAST.root;
2080                returnAST = annotationMemberArrayInitializer_AST;
2081        }
2082        
2083        public final void annotationMemberArrayValueInitializer() throws RecognitionException, TokenStreamException {
2084                
2085                returnAST = null;
2086                ASTPair currentAST = new ASTPair();
2087                AST annotationMemberArrayValueInitializer_AST = null;
2088                
2089                switch ( LA(1)) {
2090                case LITERAL_void:
2091                case LITERAL_boolean:
2092                case LITERAL_byte:
2093                case LITERAL_char:
2094                case LITERAL_short:
2095                case LITERAL_int:
2096                case LITERAL_float:
2097                case LITERAL_long:
2098                case LITERAL_double:
2099                case IDENT:
2100                case LPAREN:
2101                case LITERAL_this:
2102                case LITERAL_super:
2103                case PLUS:
2104                case MINUS:
2105                case INC:
2106                case DEC:
2107                case BNOT:
2108                case LNOT:
2109                case LITERAL_true:
2110                case LITERAL_false:
2111                case LITERAL_null:
2112                case LITERAL_new:
2113                case NUM_INT:
2114                case CHAR_LITERAL:
2115                case STRING_LITERAL:
2116                case NUM_FLOAT:
2117                case NUM_LONG:
2118                case NUM_DOUBLE:
2119                {
2120                        annotationExpression();
2121                        astFactory.addASTChild(currentAST, returnAST);
2122                        annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
2123                        break;
2124                }
2125                case AT:
2126                {
2127                        annotation();
2128                        astFactory.addASTChild(currentAST, returnAST);
2129                        annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
2130                        break;
2131                }
2132                default:
2133                {
2134                        throw new NoViableAltException(LT(1), getFilename());
2135                }
2136                }
2137                returnAST = annotationMemberArrayValueInitializer_AST;
2138        }
2139        
2140        public final void conditionalExpression() throws RecognitionException, TokenStreamException {
2141                
2142                returnAST = null;
2143                ASTPair currentAST = new ASTPair();
2144                AST conditionalExpression_AST = null;
2145                
2146                logicalOrExpression();
2147                astFactory.addASTChild(currentAST, returnAST);
2148                {
2149                switch ( LA(1)) {
2150                case QUESTION:
2151                {
2152                        AST tmp54_AST = null;
2153                        tmp54_AST = astFactory.create(LT(1));
2154                        astFactory.makeASTRoot(currentAST, tmp54_AST);
2155                        match(QUESTION);
2156                        {
2157                        boolean synPredMatched272 = false;
2158                        if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
2159                                int _m272 = mark();
2160                                synPredMatched272 = true;
2161                                inputState.guessing++;
2162                                try {
2163                                        {
2164                                        lambdaExpression();
2165                                        }
2166                                }
2167                                catch (RecognitionException pe) {
2168                                        synPredMatched272 = false;
2169                                }
2170                                rewind(_m272);
2171inputState.guessing--;
2172                        }
2173                        if ( synPredMatched272 ) {
2174                                lambdaExpression();
2175                                astFactory.addASTChild(currentAST, returnAST);
2176                        }
2177                        else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_17.member(LA(2)))) {
2178                                assignmentExpression();
2179                                astFactory.addASTChild(currentAST, returnAST);
2180                        }
2181                        else {
2182                                throw new NoViableAltException(LT(1), getFilename());
2183                        }
2184                        
2185                        }
2186                        AST tmp55_AST = null;
2187                        tmp55_AST = astFactory.create(LT(1));
2188                        astFactory.addASTChild(currentAST, tmp55_AST);
2189                        match(COLON);
2190                        {
2191                        boolean synPredMatched275 = false;
2192                        if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
2193                                int _m275 = mark();
2194                                synPredMatched275 = true;
2195                                inputState.guessing++;
2196                                try {
2197                                        {
2198                                        lambdaExpression();
2199                                        }
2200                                }
2201                                catch (RecognitionException pe) {
2202                                        synPredMatched275 = false;
2203                                }
2204                                rewind(_m275);
2205inputState.guessing--;
2206                        }
2207                        if ( synPredMatched275 ) {
2208                                lambdaExpression();
2209                                astFactory.addASTChild(currentAST, returnAST);
2210                        }
2211                        else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_18.member(LA(2)))) {
2212                                conditionalExpression();
2213                                astFactory.addASTChild(currentAST, returnAST);
2214                        }
2215                        else {
2216                                throw new NoViableAltException(LT(1), getFilename());
2217                        }
2218                        
2219                        }
2220                        break;
2221                }
2222                case FINAL:
2223                case ABSTRACT:
2224                case STRICTFP:
2225                case SEMI:
2226                case RBRACK:
2227                case LITERAL_void:
2228                case LITERAL_boolean:
2229                case LITERAL_byte:
2230                case LITERAL_char:
2231                case LITERAL_short:
2232                case LITERAL_int:
2233                case LITERAL_float:
2234                case LITERAL_long:
2235                case LITERAL_double:
2236                case IDENT:
2237                case LITERAL_private:
2238                case LITERAL_public:
2239                case LITERAL_protected:
2240                case LITERAL_static:
2241                case LITERAL_transient:
2242                case LITERAL_native:
2243                case LITERAL_synchronized:
2244                case LITERAL_volatile:
2245                case LITERAL_class:
2246                case LITERAL_interface:
2247                case LCURLY:
2248                case RCURLY:
2249                case COMMA:
2250                case LPAREN:
2251                case RPAREN:
2252                case LITERAL_this:
2253                case LITERAL_super:
2254                case ASSIGN:
2255                case COLON:
2256                case LITERAL_if:
2257                case LITERAL_while:
2258                case LITERAL_do:
2259                case LITERAL_break:
2260                case LITERAL_continue:
2261                case LITERAL_return:
2262                case LITERAL_switch:
2263                case LITERAL_throw:
2264                case LITERAL_for:
2265                case LITERAL_else:
2266                case LITERAL_case:
2267                case LITERAL_default:
2268                case LITERAL_try:
2269                case PLUS_ASSIGN:
2270                case MINUS_ASSIGN:
2271                case STAR_ASSIGN:
2272                case DIV_ASSIGN:
2273                case MOD_ASSIGN:
2274                case SR_ASSIGN:
2275                case BSR_ASSIGN:
2276                case SL_ASSIGN:
2277                case BAND_ASSIGN:
2278                case BXOR_ASSIGN:
2279                case BOR_ASSIGN:
2280                case LT:
2281                case PLUS:
2282                case MINUS:
2283                case INC:
2284                case DEC:
2285                case BNOT:
2286                case LNOT:
2287                case LITERAL_true:
2288                case LITERAL_false:
2289                case LITERAL_null:
2290                case LITERAL_new:
2291                case NUM_INT:
2292                case CHAR_LITERAL:
2293                case STRING_LITERAL:
2294                case NUM_FLOAT:
2295                case NUM_LONG:
2296                case NUM_DOUBLE:
2297                case ASSERT:
2298                case ENUM:
2299                case AT:
2300                {
2301                        break;
2302                }
2303                default:
2304                {
2305                        throw new NoViableAltException(LT(1), getFilename());
2306                }
2307                }
2308                }
2309                conditionalExpression_AST = (AST)currentAST.root;
2310                returnAST = conditionalExpression_AST;
2311        }
2312        
2313        public final void typeParameters() throws RecognitionException, TokenStreamException {
2314                
2315                returnAST = null;
2316                ASTPair currentAST = new ASTPair();
2317                AST typeParameters_AST = null;
2318                Token  lt = null;
2319                AST lt_AST = null;
2320                int currentLtLevel = 0;
2321                
2322                if ( inputState.guessing==0 ) {
2323                        currentLtLevel = ltCounter;
2324                }
2325                lt = LT(1);
2326                lt_AST = astFactory.create(lt);
2327                astFactory.addASTChild(currentAST, lt_AST);
2328                match(LT);
2329                if ( inputState.guessing==0 ) {
2330                        lt_AST.setType(GENERIC_START); ltCounter++;
2331                }
2332                typeParameter();
2333                astFactory.addASTChild(currentAST, returnAST);
2334                {
2335                _loop92:
2336                do {
2337                        if ((LA(1)==COMMA)) {
2338                                AST tmp56_AST = null;
2339                                tmp56_AST = astFactory.create(LT(1));
2340                                astFactory.addASTChild(currentAST, tmp56_AST);
2341                                match(COMMA);
2342                                typeParameter();
2343                                astFactory.addASTChild(currentAST, returnAST);
2344                        }
2345                        else {
2346                                break _loop92;
2347                        }
2348                        
2349                } while (true);
2350                }
2351                {
2352                switch ( LA(1)) {
2353                case GT:
2354                case SR:
2355                case BSR:
2356                {
2357                        typeArgumentsOrParametersEnd();
2358                        astFactory.addASTChild(currentAST, returnAST);
2359                        break;
2360                }
2361                case LITERAL_void:
2362                case LITERAL_boolean:
2363                case LITERAL_byte:
2364                case LITERAL_char:
2365                case LITERAL_short:
2366                case LITERAL_int:
2367                case LITERAL_float:
2368                case LITERAL_long:
2369                case LITERAL_double:
2370                case IDENT:
2371                case LITERAL_extends:
2372                case LCURLY:
2373                case LITERAL_implements:
2374                case AT:
2375                {
2376                        break;
2377                }
2378                default:
2379                {
2380                        throw new NoViableAltException(LT(1), getFilename());
2381                }
2382                }
2383                }
2384                if ( inputState.guessing==0 ) {
2385                        
2386                        if (isThereASingleGtToEmit()) {
2387                        astFactory.addASTChild(currentAST, emitSingleGt());
2388                        }
2389                        
2390                }
2391                if (!(areLtsAndGtsBalanced(currentLtLevel)))
2392                  throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)");
2393                if ( inputState.guessing==0 ) {
2394                        typeParameters_AST = (AST)currentAST.root;
2395                        typeParameters_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETERS,"TYPE_PARAMETERS")).add(typeParameters_AST));
2396                        currentAST.root = typeParameters_AST;
2397                        currentAST.child = typeParameters_AST!=null &&typeParameters_AST.getFirstChild()!=null ?
2398                                typeParameters_AST.getFirstChild() : typeParameters_AST;
2399                        currentAST.advanceChildToEnd();
2400                }
2401                typeParameters_AST = (AST)currentAST.root;
2402                returnAST = typeParameters_AST;
2403        }
2404        
2405        public final void superClassClause() throws RecognitionException, TokenStreamException {
2406                
2407                returnAST = null;
2408                ASTPair currentAST = new ASTPair();
2409                AST superClassClause_AST = null;
2410                Token  e = null;
2411                AST e_AST = null;
2412                AST c_AST = null;
2413                
2414                {
2415                switch ( LA(1)) {
2416                case LITERAL_extends:
2417                {
2418                        e = LT(1);
2419                        e_AST = astFactory.create(e);
2420                        astFactory.makeASTRoot(currentAST, e_AST);
2421                        match(LITERAL_extends);
2422                        if ( inputState.guessing==0 ) {
2423                                e_AST.setType(EXTENDS_CLAUSE);
2424                        }
2425                        classOrInterfaceType(false);
2426                        c_AST = (AST)returnAST;
2427                        astFactory.addASTChild(currentAST, returnAST);
2428                        break;
2429                }
2430                case LCURLY:
2431                case LITERAL_implements:
2432                {
2433                        break;
2434                }
2435                default:
2436                {
2437                        throw new NoViableAltException(LT(1), getFilename());
2438                }
2439                }
2440                }
2441                superClassClause_AST = (AST)currentAST.root;
2442                returnAST = superClassClause_AST;
2443        }
2444        
2445        public final void implementsClause() throws RecognitionException, TokenStreamException {
2446                
2447                returnAST = null;
2448                ASTPair currentAST = new ASTPair();
2449                AST implementsClause_AST = null;
2450                Token  i = null;
2451                AST i_AST = null;
2452                
2453                {
2454                switch ( LA(1)) {
2455                case LITERAL_implements:
2456                {
2457                        i = LT(1);
2458                        i_AST = astFactory.create(i);
2459                        astFactory.makeASTRoot(currentAST, i_AST);
2460                        match(LITERAL_implements);
2461                        if ( inputState.guessing==0 ) {
2462                                i_AST.setType(IMPLEMENTS_CLAUSE);
2463                        }
2464                        classOrInterfaceType(false);
2465                        astFactory.addASTChild(currentAST, returnAST);
2466                        {
2467                        _loop138:
2468                        do {
2469                                if ((LA(1)==COMMA)) {
2470                                        AST tmp57_AST = null;
2471                                        tmp57_AST = astFactory.create(LT(1));
2472                                        astFactory.addASTChild(currentAST, tmp57_AST);
2473                                        match(COMMA);
2474                                        classOrInterfaceType(false);
2475                                        astFactory.addASTChild(currentAST, returnAST);
2476                                }
2477                                else {
2478                                        break _loop138;
2479                                }
2480                                
2481                        } while (true);
2482                        }
2483                        break;
2484                }
2485                case LCURLY:
2486                {
2487                        break;
2488                }
2489                default:
2490                {
2491                        throw new NoViableAltException(LT(1), getFilename());
2492                }
2493                }
2494                }
2495                implementsClause_AST = (AST)currentAST.root;
2496                returnAST = implementsClause_AST;
2497        }
2498        
2499        public final void classBlock() throws RecognitionException, TokenStreamException {
2500                
2501                returnAST = null;
2502                ASTPair currentAST = new ASTPair();
2503                AST classBlock_AST = null;
2504                
2505                AST tmp58_AST = null;
2506                tmp58_AST = astFactory.create(LT(1));
2507                astFactory.addASTChild(currentAST, tmp58_AST);
2508                match(LCURLY);
2509                {
2510                _loop130:
2511                do {
2512                        switch ( LA(1)) {
2513                        case FINAL:
2514                        case ABSTRACT:
2515                        case STRICTFP:
2516                        case LITERAL_void:
2517                        case LITERAL_boolean:
2518                        case LITERAL_byte:
2519                        case LITERAL_char:
2520                        case LITERAL_short:
2521                        case LITERAL_int:
2522                        case LITERAL_float:
2523                        case LITERAL_long:
2524                        case LITERAL_double:
2525                        case IDENT:
2526                        case LITERAL_private:
2527                        case LITERAL_public:
2528                        case LITERAL_protected:
2529                        case LITERAL_static:
2530                        case LITERAL_transient:
2531                        case LITERAL_native:
2532                        case LITERAL_synchronized:
2533                        case LITERAL_volatile:
2534                        case LITERAL_class:
2535                        case LITERAL_interface:
2536                        case LCURLY:
2537                        case LITERAL_default:
2538                        case LT:
2539                        case ENUM:
2540                        case AT:
2541                        {
2542                                field();
2543                                astFactory.addASTChild(currentAST, returnAST);
2544                                break;
2545                        }
2546                        case SEMI:
2547                        {
2548                                AST tmp59_AST = null;
2549                                tmp59_AST = astFactory.create(LT(1));
2550                                astFactory.addASTChild(currentAST, tmp59_AST);
2551                                match(SEMI);
2552                                break;
2553                        }
2554                        default:
2555                        {
2556                                break _loop130;
2557                        }
2558                        }
2559                } while (true);
2560                }
2561                AST tmp60_AST = null;
2562                tmp60_AST = astFactory.create(LT(1));
2563                astFactory.addASTChild(currentAST, tmp60_AST);
2564                match(RCURLY);
2565                if ( inputState.guessing==0 ) {
2566                        classBlock_AST = (AST)currentAST.root;
2567                        classBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(classBlock_AST));
2568                        currentAST.root = classBlock_AST;
2569                        currentAST.child = classBlock_AST!=null &&classBlock_AST.getFirstChild()!=null ?
2570                                classBlock_AST.getFirstChild() : classBlock_AST;
2571                        currentAST.advanceChildToEnd();
2572                }
2573                classBlock_AST = (AST)currentAST.root;
2574                returnAST = classBlock_AST;
2575        }
2576        
2577        public final void interfaceExtends() throws RecognitionException, TokenStreamException {
2578                
2579                returnAST = null;
2580                ASTPair currentAST = new ASTPair();
2581                AST interfaceExtends_AST = null;
2582                Token  e = null;
2583                AST e_AST = null;
2584                
2585                {
2586                switch ( LA(1)) {
2587                case LITERAL_extends:
2588                {
2589                        e = LT(1);
2590                        e_AST = astFactory.create(e);
2591                        astFactory.makeASTRoot(currentAST, e_AST);
2592                        match(LITERAL_extends);
2593                        if ( inputState.guessing==0 ) {
2594                                e_AST.setType(EXTENDS_CLAUSE);
2595                        }
2596                        classOrInterfaceType(false);
2597                        astFactory.addASTChild(currentAST, returnAST);
2598                        {
2599                        _loop134:
2600                        do {
2601                                if ((LA(1)==COMMA)) {
2602                                        AST tmp61_AST = null;
2603                                        tmp61_AST = astFactory.create(LT(1));
2604                                        astFactory.addASTChild(currentAST, tmp61_AST);
2605                                        match(COMMA);
2606                                        classOrInterfaceType(false);
2607                                        astFactory.addASTChild(currentAST, returnAST);
2608                                }
2609                                else {
2610                                        break _loop134;
2611                                }
2612                                
2613                        } while (true);
2614                        }
2615                        break;
2616                }
2617                case LCURLY:
2618                {
2619                        break;
2620                }
2621                default:
2622                {
2623                        throw new NoViableAltException(LT(1), getFilename());
2624                }
2625                }
2626                }
2627                interfaceExtends_AST = (AST)currentAST.root;
2628                returnAST = interfaceExtends_AST;
2629        }
2630        
2631        public final void enumBlock() throws RecognitionException, TokenStreamException {
2632                
2633                returnAST = null;
2634                ASTPair currentAST = new ASTPair();
2635                AST enumBlock_AST = null;
2636                
2637                AST tmp62_AST = null;
2638                tmp62_AST = astFactory.create(LT(1));
2639                astFactory.addASTChild(currentAST, tmp62_AST);
2640                match(LCURLY);
2641                {
2642                switch ( LA(1)) {
2643                case IDENT:
2644                case AT:
2645                {
2646                        enumConstant();
2647                        astFactory.addASTChild(currentAST, returnAST);
2648                        {
2649                        _loop111:
2650                        do {
2651                                if ((LA(1)==COMMA) && (LA(2)==IDENT||LA(2)==AT)) {
2652                                        AST tmp63_AST = null;
2653                                        tmp63_AST = astFactory.create(LT(1));
2654                                        astFactory.addASTChild(currentAST, tmp63_AST);
2655                                        match(COMMA);
2656                                        enumConstant();
2657                                        astFactory.addASTChild(currentAST, returnAST);
2658                                }
2659                                else {
2660                                        break _loop111;
2661                                }
2662                                
2663                        } while (true);
2664                        }
2665                        {
2666                        switch ( LA(1)) {
2667                        case COMMA:
2668                        {
2669                                AST tmp64_AST = null;
2670                                tmp64_AST = astFactory.create(LT(1));
2671                                astFactory.addASTChild(currentAST, tmp64_AST);
2672                                match(COMMA);
2673                                break;
2674                        }
2675                        case SEMI:
2676                        case RCURLY:
2677                        {
2678                                break;
2679                        }
2680                        default:
2681                        {
2682                                throw new NoViableAltException(LT(1), getFilename());
2683                        }
2684                        }
2685                        }
2686                        break;
2687                }
2688                case SEMI:
2689                case RCURLY:
2690                {
2691                        break;
2692                }
2693                default:
2694                {
2695                        throw new NoViableAltException(LT(1), getFilename());
2696                }
2697                }
2698                }
2699                {
2700                switch ( LA(1)) {
2701                case SEMI:
2702                {
2703                        AST tmp65_AST = null;
2704                        tmp65_AST = astFactory.create(LT(1));
2705                        astFactory.addASTChild(currentAST, tmp65_AST);
2706                        match(SEMI);
2707                        {
2708                        _loop115:
2709                        do {
2710                                switch ( LA(1)) {
2711                                case FINAL:
2712                                case ABSTRACT:
2713                                case STRICTFP:
2714                                case LITERAL_void:
2715                                case LITERAL_boolean:
2716                                case LITERAL_byte:
2717                                case LITERAL_char:
2718                                case LITERAL_short:
2719                                case LITERAL_int:
2720                                case LITERAL_float:
2721                                case LITERAL_long:
2722                                case LITERAL_double:
2723                                case IDENT:
2724                                case LITERAL_private:
2725                                case LITERAL_public:
2726                                case LITERAL_protected:
2727                                case LITERAL_static:
2728                                case LITERAL_transient:
2729                                case LITERAL_native:
2730                                case LITERAL_synchronized:
2731                                case LITERAL_volatile:
2732                                case LITERAL_class:
2733                                case LITERAL_interface:
2734                                case LCURLY:
2735                                case LITERAL_default:
2736                                case LT:
2737                                case ENUM:
2738                                case AT:
2739                                {
2740                                        field();
2741                                        astFactory.addASTChild(currentAST, returnAST);
2742                                        break;
2743                                }
2744                                case SEMI:
2745                                {
2746                                        AST tmp66_AST = null;
2747                                        tmp66_AST = astFactory.create(LT(1));
2748                                        astFactory.addASTChild(currentAST, tmp66_AST);
2749                                        match(SEMI);
2750                                        break;
2751                                }
2752                                default:
2753                                {
2754                                        break _loop115;
2755                                }
2756                                }
2757                        } while (true);
2758                        }
2759                        break;
2760                }
2761                case RCURLY:
2762                {
2763                        break;
2764                }
2765                default:
2766                {
2767                        throw new NoViableAltException(LT(1), getFilename());
2768                }
2769                }
2770                }
2771                AST tmp67_AST = null;
2772                tmp67_AST = astFactory.create(LT(1));
2773                astFactory.addASTChild(currentAST, tmp67_AST);
2774                match(RCURLY);
2775                if ( inputState.guessing==0 ) {
2776                        enumBlock_AST = (AST)currentAST.root;
2777                        enumBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumBlock_AST));
2778                        currentAST.root = enumBlock_AST;
2779                        currentAST.child = enumBlock_AST!=null &&enumBlock_AST.getFirstChild()!=null ?
2780                                enumBlock_AST.getFirstChild() : enumBlock_AST;
2781                        currentAST.advanceChildToEnd();
2782                }
2783                enumBlock_AST = (AST)currentAST.root;
2784                returnAST = enumBlock_AST;
2785        }
2786        
2787        public final void annotationBlock() throws RecognitionException, TokenStreamException {
2788                
2789                returnAST = null;
2790                ASTPair currentAST = new ASTPair();
2791                AST annotationBlock_AST = null;
2792                
2793                AST tmp68_AST = null;
2794                tmp68_AST = astFactory.create(LT(1));
2795                astFactory.addASTChild(currentAST, tmp68_AST);
2796                match(LCURLY);
2797                {
2798                _loop102:
2799                do {
2800                        switch ( LA(1)) {
2801                        case FINAL:
2802                        case ABSTRACT:
2803                        case STRICTFP:
2804                        case LITERAL_void:
2805                        case LITERAL_boolean:
2806                        case LITERAL_byte:
2807                        case LITERAL_char:
2808                        case LITERAL_short:
2809                        case LITERAL_int:
2810                        case LITERAL_float:
2811                        case LITERAL_long:
2812                        case LITERAL_double:
2813                        case IDENT:
2814                        case LITERAL_private:
2815                        case LITERAL_public:
2816                        case LITERAL_protected:
2817                        case LITERAL_static:
2818                        case LITERAL_transient:
2819                        case LITERAL_native:
2820                        case LITERAL_synchronized:
2821                        case LITERAL_volatile:
2822                        case LITERAL_class:
2823                        case LITERAL_interface:
2824                        case LITERAL_default:
2825                        case ENUM:
2826                        case AT:
2827                        {
2828                                annotationField();
2829                                astFactory.addASTChild(currentAST, returnAST);
2830                                break;
2831                        }
2832                        case SEMI:
2833                        {
2834                                AST tmp69_AST = null;
2835                                tmp69_AST = astFactory.create(LT(1));
2836                                astFactory.addASTChild(currentAST, tmp69_AST);
2837                                match(SEMI);
2838                                break;
2839                        }
2840                        default:
2841                        {
2842                                break _loop102;
2843                        }
2844                        }
2845                } while (true);
2846                }
2847                AST tmp70_AST = null;
2848                tmp70_AST = astFactory.create(LT(1));
2849                astFactory.addASTChild(currentAST, tmp70_AST);
2850                match(RCURLY);
2851                if ( inputState.guessing==0 ) {
2852                        annotationBlock_AST = (AST)currentAST.root;
2853                        annotationBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(annotationBlock_AST));
2854                        currentAST.root = annotationBlock_AST;
2855                        currentAST.child = annotationBlock_AST!=null &&annotationBlock_AST.getFirstChild()!=null ?
2856                                annotationBlock_AST.getFirstChild() : annotationBlock_AST;
2857                        currentAST.advanceChildToEnd();
2858                }
2859                annotationBlock_AST = (AST)currentAST.root;
2860                returnAST = annotationBlock_AST;
2861        }
2862        
2863        public final void typeParameter() throws RecognitionException, TokenStreamException {
2864                
2865                returnAST = null;
2866                ASTPair currentAST = new ASTPair();
2867                AST typeParameter_AST = null;
2868                Token  id = null;
2869                AST id_AST = null;
2870                
2871                {
2872                id = LT(1);
2873                id_AST = astFactory.create(id);
2874                astFactory.addASTChild(currentAST, id_AST);
2875                match(IDENT);
2876                }
2877                {
2878                if ((LA(1)==LITERAL_extends) && (LA(2)==IDENT||LA(2)==AT)) {
2879                        typeParameterBounds();
2880                        astFactory.addASTChild(currentAST, returnAST);
2881                }
2882                else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_20.member(LA(2)))) {
2883                }
2884                else {
2885                        throw new NoViableAltException(LT(1), getFilename());
2886                }
2887                
2888                }
2889                if ( inputState.guessing==0 ) {
2890                        typeParameter_AST = (AST)currentAST.root;
2891                        typeParameter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETER,"TYPE_PARAMETER")).add(typeParameter_AST));
2892                        currentAST.root = typeParameter_AST;
2893                        currentAST.child = typeParameter_AST!=null &&typeParameter_AST.getFirstChild()!=null ?
2894                                typeParameter_AST.getFirstChild() : typeParameter_AST;
2895                        currentAST.advanceChildToEnd();
2896                }
2897                typeParameter_AST = (AST)currentAST.root;
2898                returnAST = typeParameter_AST;
2899        }
2900        
2901        public final void typeParameterBounds() throws RecognitionException, TokenStreamException {
2902                
2903                returnAST = null;
2904                ASTPair currentAST = new ASTPair();
2905                AST typeParameterBounds_AST = null;
2906                Token  e = null;
2907                AST e_AST = null;
2908                Token  b = null;
2909                AST b_AST = null;
2910                
2911                e = LT(1);
2912                e_AST = astFactory.create(e);
2913                astFactory.makeASTRoot(currentAST, e_AST);
2914                match(LITERAL_extends);
2915                classOrInterfaceType(true);
2916                astFactory.addASTChild(currentAST, returnAST);
2917                {
2918                _loop99:
2919                do {
2920                        if ((LA(1)==BAND)) {
2921                                b = LT(1);
2922                                b_AST = astFactory.create(b);
2923                                astFactory.addASTChild(currentAST, b_AST);
2924                                match(BAND);
2925                                if ( inputState.guessing==0 ) {
2926                                        b_AST.setType(TYPE_EXTENSION_AND);
2927                                }
2928                                classOrInterfaceType(true);
2929                                astFactory.addASTChild(currentAST, returnAST);
2930                        }
2931                        else {
2932                                break _loop99;
2933                        }
2934                        
2935                } while (true);
2936                }
2937                if ( inputState.guessing==0 ) {
2938                        e_AST.setType(TYPE_UPPER_BOUNDS);
2939                }
2940                typeParameterBounds_AST = (AST)currentAST.root;
2941                returnAST = typeParameterBounds_AST;
2942        }
2943        
2944        public final void annotationField() throws RecognitionException, TokenStreamException {
2945                
2946                returnAST = null;
2947                ASTPair currentAST = new ASTPair();
2948                AST annotationField_AST = null;
2949                AST mods_AST = null;
2950                AST td_AST = null;
2951                AST t_AST = null;
2952                Token  i = null;
2953                AST i_AST = null;
2954                AST rt_AST = null;
2955                AST d_AST = null;
2956                Token  s = null;
2957                AST s_AST = null;
2958                AST v_AST = null;
2959                Token  s6 = null;
2960                AST s6_AST = null;
2961                
2962                modifiers();
2963                mods_AST = (AST)returnAST;
2964                {
2965                if ((_tokenSet_21.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
2966                        typeDefinitionInternal(mods_AST);
2967                        td_AST = (AST)returnAST;
2968                        if ( inputState.guessing==0 ) {
2969                                annotationField_AST = (AST)currentAST.root;
2970                                annotationField_AST = td_AST;
2971                                currentAST.root = annotationField_AST;
2972                                currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
2973                                        annotationField_AST.getFirstChild() : annotationField_AST;
2974                                currentAST.advanceChildToEnd();
2975                        }
2976                }
2977                else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2978                        typeSpec(false);
2979                        t_AST = (AST)returnAST;
2980                        {
2981                        if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
2982                                i = LT(1);
2983                                i_AST = astFactory.create(i);
2984                                match(IDENT);
2985                                AST tmp71_AST = null;
2986                                tmp71_AST = astFactory.create(LT(1));
2987                                match(LPAREN);
2988                                AST tmp72_AST = null;
2989                                tmp72_AST = astFactory.create(LT(1));
2990                                match(RPAREN);
2991                                declaratorBrackets(t_AST);
2992                                rt_AST = (AST)returnAST;
2993                                {
2994                                switch ( LA(1)) {
2995                                case LITERAL_default:
2996                                {
2997                                        annotationDefault();
2998                                        d_AST = (AST)returnAST;
2999                                        break;
3000                                }
3001                                case SEMI:
3002                                {
3003                                        break;
3004                                }
3005                                default:
3006                                {
3007                                        throw new NoViableAltException(LT(1), getFilename());
3008                                }
3009                                }
3010                                }
3011                                s = LT(1);
3012                                s_AST = astFactory.create(s);
3013                                match(SEMI);
3014                                if ( inputState.guessing==0 ) {
3015                                        annotationField_AST = (AST)currentAST.root;
3016                                        annotationField_AST =
3017                                        (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF")).add(mods_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(i_AST).add(tmp71_AST).add(tmp72_AST).add(d_AST).add(s_AST));
3018                                        currentAST.root = annotationField_AST;
3019                                        currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
3020                                                annotationField_AST.getFirstChild() : annotationField_AST;
3021                                        currentAST.advanceChildToEnd();
3022                                }
3023                        }
3024                        else if ((LA(1)==IDENT) && (_tokenSet_23.member(LA(2)))) {
3025                                variableDefinitions(mods_AST,t_AST);
3026                                v_AST = (AST)returnAST;
3027                                s6 = LT(1);
3028                                s6_AST = astFactory.create(s6);
3029                                match(SEMI);
3030                                if ( inputState.guessing==0 ) {
3031                                        annotationField_AST = (AST)currentAST.root;
3032                                        
3033                                        annotationField_AST = v_AST;
3034                                        v_AST.addChild(s6_AST);
3035                                        
3036                                        currentAST.root = annotationField_AST;
3037                                        currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
3038                                                annotationField_AST.getFirstChild() : annotationField_AST;
3039                                        currentAST.advanceChildToEnd();
3040                                }
3041                        }
3042                        else {
3043                                throw new NoViableAltException(LT(1), getFilename());
3044                        }
3045                        
3046                        }
3047                }
3048                else {
3049                        throw new NoViableAltException(LT(1), getFilename());
3050                }
3051                
3052                }
3053                returnAST = annotationField_AST;
3054        }
3055        
3056        public final void declaratorBrackets(
3057                AST typ
3058        ) throws RecognitionException, TokenStreamException {
3059                
3060                returnAST = null;
3061                ASTPair currentAST = new ASTPair();
3062                AST declaratorBrackets_AST = null;
3063                Token  lb = null;
3064                AST lb_AST = null;
3065                
3066                if ( inputState.guessing==0 ) {
3067                        declaratorBrackets_AST = (AST)currentAST.root;
3068                        declaratorBrackets_AST=typ;
3069                        currentAST.root = declaratorBrackets_AST;
3070                        currentAST.child = declaratorBrackets_AST!=null &&declaratorBrackets_AST.getFirstChild()!=null ?
3071                                declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST;
3072                        currentAST.advanceChildToEnd();
3073                }
3074                {
3075                _loop164:
3076                do {
3077                        if ((LA(1)==LBRACK)) {
3078                                lb = LT(1);
3079                                lb_AST = astFactory.create(lb);
3080                                astFactory.makeASTRoot(currentAST, lb_AST);
3081                                match(LBRACK);
3082                                if ( inputState.guessing==0 ) {
3083                                        lb_AST.setType(ARRAY_DECLARATOR);
3084                                }
3085                                AST tmp73_AST = null;
3086                                tmp73_AST = astFactory.create(LT(1));
3087                                astFactory.addASTChild(currentAST, tmp73_AST);
3088                                match(RBRACK);
3089                        }
3090                        else {
3091                                break _loop164;
3092                        }
3093                        
3094                } while (true);
3095                }
3096                declaratorBrackets_AST = (AST)currentAST.root;
3097                returnAST = declaratorBrackets_AST;
3098        }
3099        
3100        public final void annotationDefault() throws RecognitionException, TokenStreamException {
3101                
3102                returnAST = null;
3103                ASTPair currentAST = new ASTPair();
3104                AST annotationDefault_AST = null;
3105                
3106                AST tmp74_AST = null;
3107                tmp74_AST = astFactory.create(LT(1));
3108                astFactory.makeASTRoot(currentAST, tmp74_AST);
3109                match(LITERAL_default);
3110                annotationMemberValueInitializer();
3111                astFactory.addASTChild(currentAST, returnAST);
3112                annotationDefault_AST = (AST)currentAST.root;
3113                returnAST = annotationDefault_AST;
3114        }
3115        
3116        public final void enumConstant() throws RecognitionException, TokenStreamException {
3117                
3118                returnAST = null;
3119                ASTPair currentAST = new ASTPair();
3120                AST enumConstant_AST = null;
3121                AST an_AST = null;
3122                Token  i = null;
3123                AST i_AST = null;
3124                Token  l = null;
3125                AST l_AST = null;
3126                AST args_AST = null;
3127                Token  r = null;
3128                AST r_AST = null;
3129                AST b_AST = null;
3130                
3131                annotations();
3132                an_AST = (AST)returnAST;
3133                i = LT(1);
3134                i_AST = astFactory.create(i);
3135                match(IDENT);
3136                {
3137                switch ( LA(1)) {
3138                case LPAREN:
3139                {
3140                        l = LT(1);
3141                        l_AST = astFactory.create(l);
3142                        match(LPAREN);
3143                        argList();
3144                        args_AST = (AST)returnAST;
3145                        r = LT(1);
3146                        r_AST = astFactory.create(r);
3147                        match(RPAREN);
3148                        break;
3149                }
3150                case SEMI:
3151                case LCURLY:
3152                case RCURLY:
3153                case COMMA:
3154                {
3155                        break;
3156                }
3157                default:
3158                {
3159                        throw new NoViableAltException(LT(1), getFilename());
3160                }
3161                }
3162                }
3163                {
3164                switch ( LA(1)) {
3165                case LCURLY:
3166                {
3167                        enumConstantBlock();
3168                        b_AST = (AST)returnAST;
3169                        break;
3170                }
3171                case SEMI:
3172                case RCURLY:
3173                case COMMA:
3174                {
3175                        break;
3176                }
3177                default:
3178                {
3179                        throw new NoViableAltException(LT(1), getFilename());
3180                }
3181                }
3182                }
3183                if ( inputState.guessing==0 ) {
3184                        enumConstant_AST = (AST)currentAST.root;
3185                        enumConstant_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(ENUM_CONSTANT_DEF,"ENUM_CONSTANT_DEF")).add(an_AST).add(i_AST).add(l_AST).add(args_AST).add(r_AST).add(b_AST));
3186                        currentAST.root = enumConstant_AST;
3187                        currentAST.child = enumConstant_AST!=null &&enumConstant_AST.getFirstChild()!=null ?
3188                                enumConstant_AST.getFirstChild() : enumConstant_AST;
3189                        currentAST.advanceChildToEnd();
3190                }
3191                returnAST = enumConstant_AST;
3192        }
3193        
3194        public final void field() throws RecognitionException, TokenStreamException {
3195                
3196                returnAST = null;
3197                ASTPair currentAST = new ASTPair();
3198                AST field_AST = null;
3199                AST mods_AST = null;
3200                AST td_AST = null;
3201                AST tp_AST = null;
3202                AST h_AST = null;
3203                AST s_AST = null;
3204                AST t_AST = null;
3205                AST param_AST = null;
3206                AST rt_AST = null;
3207                AST tc_AST = null;
3208                AST s2_AST = null;
3209                Token  s5 = null;
3210                AST s5_AST = null;
3211                AST v_AST = null;
3212                Token  s6 = null;
3213                AST s6_AST = null;
3214                Token  si = null;
3215                AST si_AST = null;
3216                AST s3_AST = null;
3217                AST s4_AST = null;
3218                
3219                if ((_tokenSet_24.member(LA(1))) && (_tokenSet_25.member(LA(2)))) {
3220                        modifiers();
3221                        mods_AST = (AST)returnAST;
3222                        {
3223                        if ((_tokenSet_21.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
3224                                typeDefinitionInternal(mods_AST);
3225                                td_AST = (AST)returnAST;
3226                                if ( inputState.guessing==0 ) {
3227                                        field_AST = (AST)currentAST.root;
3228                                        field_AST = td_AST;
3229                                        currentAST.root = field_AST;
3230                                        currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3231                                                field_AST.getFirstChild() : field_AST;
3232                                        currentAST.advanceChildToEnd();
3233                                }
3234                        }
3235                        else if ((_tokenSet_26.member(LA(1))) && (_tokenSet_27.member(LA(2)))) {
3236                                {
3237                                switch ( LA(1)) {
3238                                case LT:
3239                                {
3240                                        typeParameters();
3241                                        tp_AST = (AST)returnAST;
3242                                        break;
3243                                }
3244                                case LITERAL_void:
3245                                case LITERAL_boolean:
3246                                case LITERAL_byte:
3247                                case LITERAL_char:
3248                                case LITERAL_short:
3249                                case LITERAL_int:
3250                                case LITERAL_float:
3251                                case LITERAL_long:
3252                                case LITERAL_double:
3253                                case IDENT:
3254                                case AT:
3255                                {
3256                                        break;
3257                                }
3258                                default:
3259                                {
3260                                        throw new NoViableAltException(LT(1), getFilename());
3261                                }
3262                                }
3263                                }
3264                                {
3265                                if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
3266                                        ctorHead();
3267                                        h_AST = (AST)returnAST;
3268                                        constructorBody();
3269                                        s_AST = (AST)returnAST;
3270                                        if ( inputState.guessing==0 ) {
3271                                                field_AST = (AST)currentAST.root;
3272                                                field_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(CTOR_DEF,"CTOR_DEF")).add(mods_AST).add(tp_AST).add(h_AST).add(s_AST));
3273                                                currentAST.root = field_AST;
3274                                                currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3275                                                        field_AST.getFirstChild() : field_AST;
3276                                                currentAST.advanceChildToEnd();
3277                                        }
3278                                }
3279                                else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
3280                                        typeSpec(false);
3281                                        t_AST = (AST)returnAST;
3282                                        {
3283                                        if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
3284                                                AST tmp75_AST = null;
3285                                                tmp75_AST = astFactory.create(LT(1));
3286                                                match(IDENT);
3287                                                AST tmp76_AST = null;
3288                                                tmp76_AST = astFactory.create(LT(1));
3289                                                match(LPAREN);
3290                                                parameterDeclarationList();
3291                                                param_AST = (AST)returnAST;
3292                                                AST tmp77_AST = null;
3293                                                tmp77_AST = astFactory.create(LT(1));
3294                                                match(RPAREN);
3295                                                declaratorBrackets(t_AST);
3296                                                rt_AST = (AST)returnAST;
3297                                                {
3298                                                switch ( LA(1)) {
3299                                                case LITERAL_throws:
3300                                                {
3301                                                        throwsClause();
3302                                                        tc_AST = (AST)returnAST;
3303                                                        break;
3304                                                }
3305                                                case SEMI:
3306                                                case LCURLY:
3307                                                {
3308                                                        break;
3309                                                }
3310                                                default:
3311                                                {
3312                                                        throw new NoViableAltException(LT(1), getFilename());
3313                                                }
3314                                                }
3315                                                }
3316                                                {
3317                                                switch ( LA(1)) {
3318                                                case LCURLY:
3319                                                {
3320                                                        compoundStatement();
3321                                                        s2_AST = (AST)returnAST;
3322                                                        break;
3323                                                }
3324                                                case SEMI:
3325                                                {
3326                                                        s5 = LT(1);
3327                                                        s5_AST = astFactory.create(s5);
3328                                                        match(SEMI);
3329                                                        break;
3330                                                }
3331                                                default:
3332                                                {
3333                                                        throw new NoViableAltException(LT(1), getFilename());
3334                                                }
3335                                                }
3336                                                }
3337                                                if ( inputState.guessing==0 ) {
3338                                                        field_AST = (AST)currentAST.root;
3339                                                        field_AST = (AST)astFactory.make( (new ASTArray(11)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp75_AST).add(tmp76_AST).add(param_AST).add(tmp77_AST).add(tc_AST).add(s2_AST).add(s5_AST));
3340                                                        currentAST.root = field_AST;
3341                                                        currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3342                                                                field_AST.getFirstChild() : field_AST;
3343                                                        currentAST.advanceChildToEnd();
3344                                                }
3345                                        }
3346                                        else if ((LA(1)==IDENT) && (_tokenSet_28.member(LA(2)))) {
3347                                                variableDefinitions(mods_AST,t_AST);
3348                                                v_AST = (AST)returnAST;
3349                                                {
3350                                                if ((LA(1)==SEMI) && (_tokenSet_29.member(LA(2)))) {
3351                                                        s6 = LT(1);
3352                                                        s6_AST = astFactory.create(s6);
3353                                                        match(SEMI);
3354                                                }
3355                                                else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2)))) {
3356                                                }
3357                                                else {
3358                                                        throw new NoViableAltException(LT(1), getFilename());
3359                                                }
3360                                                
3361                                                }
3362                                                if ( inputState.guessing==0 ) {
3363                                                        field_AST = (AST)currentAST.root;
3364                                                        
3365                                                        field_AST = v_AST;
3366                                                        v_AST.addChild(s6_AST);
3367                                                        
3368                                                        currentAST.root = field_AST;
3369                                                        currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3370                                                                field_AST.getFirstChild() : field_AST;
3371                                                        currentAST.advanceChildToEnd();
3372                                                }
3373                                        }
3374                                        else {
3375                                                throw new NoViableAltException(LT(1), getFilename());
3376                                        }
3377                                        
3378                                        }
3379                                }
3380                                else {
3381                                        throw new NoViableAltException(LT(1), getFilename());
3382                                }
3383                                
3384                                }
3385                        }
3386                        else {
3387                                throw new NoViableAltException(LT(1), getFilename());
3388                        }
3389                        
3390                        }
3391                }
3392                else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY)) {
3393                        si = LT(1);
3394                        si_AST = astFactory.create(si);
3395                        match(LITERAL_static);
3396                        compoundStatement();
3397                        s3_AST = (AST)returnAST;
3398                        if ( inputState.guessing==0 ) {
3399                                field_AST = (AST)currentAST.root;
3400                                si_AST.setType(STATIC_INIT);
3401                                si_AST.setText("STATIC_INIT");
3402                                field_AST = (AST)astFactory.make( (new ASTArray(2)).add(si_AST).add(s3_AST));
3403                                currentAST.root = field_AST;
3404                                currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3405                                        field_AST.getFirstChild() : field_AST;
3406                                currentAST.advanceChildToEnd();
3407                        }
3408                }
3409                else if ((LA(1)==LCURLY)) {
3410                        compoundStatement();
3411                        s4_AST = (AST)returnAST;
3412                        if ( inputState.guessing==0 ) {
3413                                field_AST = (AST)currentAST.root;
3414                                field_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST));
3415                                currentAST.root = field_AST;
3416                                currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3417                                        field_AST.getFirstChild() : field_AST;
3418                                currentAST.advanceChildToEnd();
3419                        }
3420                }
3421                else {
3422                        throw new NoViableAltException(LT(1), getFilename());
3423                }
3424                
3425                returnAST = field_AST;
3426        }
3427        
3428        public final void argList() throws RecognitionException, TokenStreamException {
3429                
3430                returnAST = null;
3431                ASTPair currentAST = new ASTPair();
3432                AST argList_AST = null;
3433                
3434                {
3435                if (((_tokenSet_16.member(LA(1))))&&(LA(1)!=RPAREN)) {
3436                        expressionList();
3437                        astFactory.addASTChild(currentAST, returnAST);
3438                }
3439                else if ((LA(1)==RPAREN)) {
3440                        if ( inputState.guessing==0 ) {
3441                                argList_AST = (AST)currentAST.root;
3442                                argList_AST = astFactory.create(ELIST,"ELIST");
3443                                currentAST.root = argList_AST;
3444                                currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ?
3445                                        argList_AST.getFirstChild() : argList_AST;
3446                                currentAST.advanceChildToEnd();
3447                        }
3448                }
3449                else {
3450                        throw new NoViableAltException(LT(1), getFilename());
3451                }
3452                
3453                }
3454                argList_AST = (AST)currentAST.root;
3455                returnAST = argList_AST;
3456        }
3457        
3458        public final void enumConstantBlock() throws RecognitionException, TokenStreamException {
3459                
3460                returnAST = null;
3461                ASTPair currentAST = new ASTPair();
3462                AST enumConstantBlock_AST = null;
3463                
3464                AST tmp78_AST = null;
3465                tmp78_AST = astFactory.create(LT(1));
3466                astFactory.addASTChild(currentAST, tmp78_AST);
3467                match(LCURLY);
3468                {
3469                _loop121:
3470                do {
3471                        switch ( LA(1)) {
3472                        case FINAL:
3473                        case ABSTRACT:
3474                        case STRICTFP:
3475                        case LITERAL_void:
3476                        case LITERAL_boolean:
3477                        case LITERAL_byte:
3478                        case LITERAL_char:
3479                        case LITERAL_short:
3480                        case LITERAL_int:
3481                        case LITERAL_float:
3482                        case LITERAL_long:
3483                        case LITERAL_double:
3484                        case IDENT:
3485                        case LITERAL_private:
3486                        case LITERAL_public:
3487                        case LITERAL_protected:
3488                        case LITERAL_static:
3489                        case LITERAL_transient:
3490                        case LITERAL_native:
3491                        case LITERAL_synchronized:
3492                        case LITERAL_volatile:
3493                        case LITERAL_class:
3494                        case LITERAL_interface:
3495                        case LCURLY:
3496                        case LITERAL_default:
3497                        case LT:
3498                        case ENUM:
3499                        case AT:
3500                        {
3501                                enumConstantField();
3502                                astFactory.addASTChild(currentAST, returnAST);
3503                                break;
3504                        }
3505                        case SEMI:
3506                        {
3507                                AST tmp79_AST = null;
3508                                tmp79_AST = astFactory.create(LT(1));
3509                                astFactory.addASTChild(currentAST, tmp79_AST);
3510                                match(SEMI);
3511                                break;
3512                        }
3513                        default:
3514                        {
3515                                break _loop121;
3516                        }
3517                        }
3518                } while (true);
3519                }
3520                AST tmp80_AST = null;
3521                tmp80_AST = astFactory.create(LT(1));
3522                astFactory.addASTChild(currentAST, tmp80_AST);
3523                match(RCURLY);
3524                if ( inputState.guessing==0 ) {
3525                        enumConstantBlock_AST = (AST)currentAST.root;
3526                        enumConstantBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumConstantBlock_AST));
3527                        currentAST.root = enumConstantBlock_AST;
3528                        currentAST.child = enumConstantBlock_AST!=null &&enumConstantBlock_AST.getFirstChild()!=null ?
3529                                enumConstantBlock_AST.getFirstChild() : enumConstantBlock_AST;
3530                        currentAST.advanceChildToEnd();
3531                }
3532                enumConstantBlock_AST = (AST)currentAST.root;
3533                returnAST = enumConstantBlock_AST;
3534        }
3535        
3536        public final void enumConstantField() throws RecognitionException, TokenStreamException {
3537                
3538                returnAST = null;
3539                ASTPair currentAST = new ASTPair();
3540                AST enumConstantField_AST = null;
3541                AST mods_AST = null;
3542                AST td_AST = null;
3543                AST tp_AST = null;
3544                AST t_AST = null;
3545                AST param_AST = null;
3546                AST rt_AST = null;
3547                AST tc_AST = null;
3548                AST s2_AST = null;
3549                Token  s3 = null;
3550                AST s3_AST = null;
3551                AST v_AST = null;
3552                Token  s6 = null;
3553                AST s6_AST = null;
3554                AST s4_AST = null;
3555                
3556                switch ( LA(1)) {
3557                case FINAL:
3558                case ABSTRACT:
3559                case STRICTFP:
3560                case LITERAL_void:
3561                case LITERAL_boolean:
3562                case LITERAL_byte:
3563                case LITERAL_char:
3564                case LITERAL_short:
3565                case LITERAL_int:
3566                case LITERAL_float:
3567                case LITERAL_long:
3568                case LITERAL_double:
3569                case IDENT:
3570                case LITERAL_private:
3571                case LITERAL_public:
3572                case LITERAL_protected:
3573                case LITERAL_static:
3574                case LITERAL_transient:
3575                case LITERAL_native:
3576                case LITERAL_synchronized:
3577                case LITERAL_volatile:
3578                case LITERAL_class:
3579                case LITERAL_interface:
3580                case LITERAL_default:
3581                case LT:
3582                case ENUM:
3583                case AT:
3584                {
3585                        modifiers();
3586                        mods_AST = (AST)returnAST;
3587                        {
3588                        if ((_tokenSet_21.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
3589                                typeDefinitionInternal(mods_AST);
3590                                td_AST = (AST)returnAST;
3591                                if ( inputState.guessing==0 ) {
3592                                        enumConstantField_AST = (AST)currentAST.root;
3593                                        enumConstantField_AST = td_AST;
3594                                        currentAST.root = enumConstantField_AST;
3595                                        currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
3596                                                enumConstantField_AST.getFirstChild() : enumConstantField_AST;
3597                                        currentAST.advanceChildToEnd();
3598                                }
3599                        }
3600                        else if ((_tokenSet_26.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
3601                                {
3602                                switch ( LA(1)) {
3603                                case LT:
3604                                {
3605                                        typeParameters();
3606                                        tp_AST = (AST)returnAST;
3607                                        break;
3608                                }
3609                                case LITERAL_void:
3610                                case LITERAL_boolean:
3611                                case LITERAL_byte:
3612                                case LITERAL_char:
3613                                case LITERAL_short:
3614                                case LITERAL_int:
3615                                case LITERAL_float:
3616                                case LITERAL_long:
3617                                case LITERAL_double:
3618                                case IDENT:
3619                                case AT:
3620                                {
3621                                        break;
3622                                }
3623                                default:
3624                                {
3625                                        throw new NoViableAltException(LT(1), getFilename());
3626                                }
3627                                }
3628                                }
3629                                typeSpec(false);
3630                                t_AST = (AST)returnAST;
3631                                {
3632                                if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
3633                                        AST tmp81_AST = null;
3634                                        tmp81_AST = astFactory.create(LT(1));
3635                                        match(IDENT);
3636                                        AST tmp82_AST = null;
3637                                        tmp82_AST = astFactory.create(LT(1));
3638                                        match(LPAREN);
3639                                        parameterDeclarationList();
3640                                        param_AST = (AST)returnAST;
3641                                        AST tmp83_AST = null;
3642                                        tmp83_AST = astFactory.create(LT(1));
3643                                        match(RPAREN);
3644                                        declaratorBrackets(t_AST);
3645                                        rt_AST = (AST)returnAST;
3646                                        {
3647                                        switch ( LA(1)) {
3648                                        case LITERAL_throws:
3649                                        {
3650                                                throwsClause();
3651                                                tc_AST = (AST)returnAST;
3652                                                break;
3653                                        }
3654                                        case SEMI:
3655                                        case LCURLY:
3656                                        {
3657                                                break;
3658                                        }
3659                                        default:
3660                                        {
3661                                                throw new NoViableAltException(LT(1), getFilename());
3662                                        }
3663                                        }
3664                                        }
3665                                        {
3666                                        switch ( LA(1)) {
3667                                        case LCURLY:
3668                                        {
3669                                                compoundStatement();
3670                                                s2_AST = (AST)returnAST;
3671                                                break;
3672                                        }
3673                                        case SEMI:
3674                                        {
3675                                                s3 = LT(1);
3676                                                s3_AST = astFactory.create(s3);
3677                                                match(SEMI);
3678                                                break;
3679                                        }
3680                                        default:
3681                                        {
3682                                                throw new NoViableAltException(LT(1), getFilename());
3683                                        }
3684                                        }
3685                                        }
3686                                        if ( inputState.guessing==0 ) {
3687                                                enumConstantField_AST = (AST)currentAST.root;
3688                                                enumConstantField_AST = (AST)astFactory.make( (new ASTArray(11)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp81_AST).add(tmp82_AST).add(param_AST).add(tmp83_AST).add(tc_AST).add(s2_AST).add(s3_AST));
3689                                                currentAST.root = enumConstantField_AST;
3690                                                currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
3691                                                        enumConstantField_AST.getFirstChild() : enumConstantField_AST;
3692                                                currentAST.advanceChildToEnd();
3693                                        }
3694                                }
3695                                else if ((LA(1)==IDENT) && (_tokenSet_23.member(LA(2)))) {
3696                                        variableDefinitions(mods_AST,t_AST);
3697                                        v_AST = (AST)returnAST;
3698                                        s6 = LT(1);
3699                                        s6_AST = astFactory.create(s6);
3700                                        match(SEMI);
3701                                        if ( inputState.guessing==0 ) {
3702                                                enumConstantField_AST = (AST)currentAST.root;
3703                                                
3704                                                enumConstantField_AST = v_AST;
3705                                                v_AST.addChild(s6_AST);
3706                                                
3707                                                currentAST.root = enumConstantField_AST;
3708                                                currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
3709                                                        enumConstantField_AST.getFirstChild() : enumConstantField_AST;
3710                                                currentAST.advanceChildToEnd();
3711                                        }
3712                                }
3713                                else {
3714                                        throw new NoViableAltException(LT(1), getFilename());
3715                                }
3716                                
3717                                }
3718                        }
3719                        else {
3720                                throw new NoViableAltException(LT(1), getFilename());
3721                        }
3722                        
3723                        }
3724                        break;
3725                }
3726                case LCURLY:
3727                {
3728                        compoundStatement();
3729                        s4_AST = (AST)returnAST;
3730                        if ( inputState.guessing==0 ) {
3731                                enumConstantField_AST = (AST)currentAST.root;
3732                                enumConstantField_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST));
3733                                currentAST.root = enumConstantField_AST;
3734                                currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
3735                                        enumConstantField_AST.getFirstChild() : enumConstantField_AST;
3736                                currentAST.advanceChildToEnd();
3737                        }
3738                        break;
3739                }
3740                default:
3741                {
3742                        throw new NoViableAltException(LT(1), getFilename());
3743                }
3744                }
3745                returnAST = enumConstantField_AST;
3746        }
3747        
3748        public final void parameterDeclarationList() throws RecognitionException, TokenStreamException {
3749                
3750                returnAST = null;
3751                ASTPair currentAST = new ASTPair();
3752                AST parameterDeclarationList_AST = null;
3753                
3754                {
3755                boolean synPredMatched182 = false;
3756                if (((_tokenSet_31.member(LA(1))) && (_tokenSet_32.member(LA(2))))) {
3757                        int _m182 = mark();
3758                        synPredMatched182 = true;
3759                        inputState.guessing++;
3760                        try {
3761                                {
3762                                parameterDeclaration();
3763                                }
3764                        }
3765                        catch (RecognitionException pe) {
3766                                synPredMatched182 = false;
3767                        }
3768                        rewind(_m182);
3769inputState.guessing--;
3770                }
3771                if ( synPredMatched182 ) {
3772                        parameterDeclaration();
3773                        astFactory.addASTChild(currentAST, returnAST);
3774                        {
3775                        _loop186:
3776                        do {
3777                                boolean synPredMatched185 = false;
3778                                if (((LA(1)==COMMA) && (_tokenSet_31.member(LA(2))))) {
3779                                        int _m185 = mark();
3780                                        synPredMatched185 = true;
3781                                        inputState.guessing++;
3782                                        try {
3783                                                {
3784                                                match(COMMA);
3785                                                parameterDeclaration();
3786                                                }
3787                                        }
3788                                        catch (RecognitionException pe) {
3789                                                synPredMatched185 = false;
3790                                        }
3791                                        rewind(_m185);
3792inputState.guessing--;
3793                                }
3794                                if ( synPredMatched185 ) {
3795                                        AST tmp84_AST = null;
3796                                        tmp84_AST = astFactory.create(LT(1));
3797                                        astFactory.addASTChild(currentAST, tmp84_AST);
3798                                        match(COMMA);
3799                                        parameterDeclaration();
3800                                        astFactory.addASTChild(currentAST, returnAST);
3801                                }
3802                                else {
3803                                        break _loop186;
3804                                }
3805                                
3806                        } while (true);
3807                        }
3808                        {
3809                        switch ( LA(1)) {
3810                        case COMMA:
3811                        {
3812                                AST tmp85_AST = null;
3813                                tmp85_AST = astFactory.create(LT(1));
3814                                astFactory.addASTChild(currentAST, tmp85_AST);
3815                                match(COMMA);
3816                                variableLengthParameterDeclaration();
3817                                astFactory.addASTChild(currentAST, returnAST);
3818                                break;
3819                        }
3820                        case RPAREN:
3821                        {
3822                                break;
3823                        }
3824                        default:
3825                        {
3826                                throw new NoViableAltException(LT(1), getFilename());
3827                        }
3828                        }
3829                        }
3830                }
3831                else if ((_tokenSet_31.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3832                        variableLengthParameterDeclaration();
3833                        astFactory.addASTChild(currentAST, returnAST);
3834                }
3835                else if ((LA(1)==RPAREN)) {
3836                }
3837                else {
3838                        throw new NoViableAltException(LT(1), getFilename());
3839                }
3840                
3841                }
3842                if ( inputState.guessing==0 ) {
3843                        parameterDeclarationList_AST = (AST)currentAST.root;
3844                        parameterDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PARAMETERS,"PARAMETERS")).add(parameterDeclarationList_AST));
3845                        currentAST.root = parameterDeclarationList_AST;
3846                        currentAST.child = parameterDeclarationList_AST!=null &&parameterDeclarationList_AST.getFirstChild()!=null ?
3847                                parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST;
3848                        currentAST.advanceChildToEnd();
3849                }
3850                parameterDeclarationList_AST = (AST)currentAST.root;
3851                returnAST = parameterDeclarationList_AST;
3852        }
3853        
3854        public final void throwsClause() throws RecognitionException, TokenStreamException {
3855                
3856                returnAST = null;
3857                ASTPair currentAST = new ASTPair();
3858                AST throwsClause_AST = null;
3859                
3860                AST tmp86_AST = null;
3861                tmp86_AST = astFactory.create(LT(1));
3862                astFactory.makeASTRoot(currentAST, tmp86_AST);
3863                match(LITERAL_throws);
3864                {
3865                if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_34.member(LA(2))))&&(LA(1) == AT)) {
3866                        annotations();
3867                        astFactory.addASTChild(currentAST, returnAST);
3868                }
3869                else if ((LA(1)==IDENT) && (_tokenSet_35.member(LA(2)))) {
3870                }
3871                else {
3872                        throw new NoViableAltException(LT(1), getFilename());
3873                }
3874                
3875                }
3876                identifier();
3877                astFactory.addASTChild(currentAST, returnAST);
3878                {
3879                _loop178:
3880                do {
3881                        if ((LA(1)==COMMA)) {
3882                                AST tmp87_AST = null;
3883                                tmp87_AST = astFactory.create(LT(1));
3884                                astFactory.addASTChild(currentAST, tmp87_AST);
3885                                match(COMMA);
3886                                identifier();
3887                                astFactory.addASTChild(currentAST, returnAST);
3888                        }
3889                        else {
3890                                break _loop178;
3891                        }
3892                        
3893                } while (true);
3894                }
3895                throwsClause_AST = (AST)currentAST.root;
3896                returnAST = throwsClause_AST;
3897        }
3898        
3899        public final void compoundStatement() throws RecognitionException, TokenStreamException {
3900                
3901                returnAST = null;
3902                ASTPair currentAST = new ASTPair();
3903                AST compoundStatement_AST = null;
3904                Token  lc = null;
3905                AST lc_AST = null;
3906                
3907                lc = LT(1);
3908                lc_AST = astFactory.create(lc);
3909                astFactory.makeASTRoot(currentAST, lc_AST);
3910                match(LCURLY);
3911                if ( inputState.guessing==0 ) {
3912                        lc_AST.setType(SLIST);
3913                }
3914                {
3915                _loop203:
3916                do {
3917                        if ((_tokenSet_36.member(LA(1)))) {
3918                                statement();
3919                                astFactory.addASTChild(currentAST, returnAST);
3920                        }
3921                        else {
3922                                break _loop203;
3923                        }
3924                        
3925                } while (true);
3926                }
3927                AST tmp88_AST = null;
3928                tmp88_AST = astFactory.create(LT(1));
3929                astFactory.addASTChild(currentAST, tmp88_AST);
3930                match(RCURLY);
3931                compoundStatement_AST = (AST)currentAST.root;
3932                returnAST = compoundStatement_AST;
3933        }
3934        
3935        public final void ctorHead() throws RecognitionException, TokenStreamException {
3936                
3937                returnAST = null;
3938                ASTPair currentAST = new ASTPair();
3939                AST ctorHead_AST = null;
3940                
3941                AST tmp89_AST = null;
3942                tmp89_AST = astFactory.create(LT(1));
3943                astFactory.addASTChild(currentAST, tmp89_AST);
3944                match(IDENT);
3945                AST tmp90_AST = null;
3946                tmp90_AST = astFactory.create(LT(1));
3947                astFactory.addASTChild(currentAST, tmp90_AST);
3948                match(LPAREN);
3949                parameterDeclarationList();
3950                astFactory.addASTChild(currentAST, returnAST);
3951                AST tmp91_AST = null;
3952                tmp91_AST = astFactory.create(LT(1));
3953                astFactory.addASTChild(currentAST, tmp91_AST);
3954                match(RPAREN);
3955                {
3956                switch ( LA(1)) {
3957                case LITERAL_throws:
3958                {
3959                        throwsClause();
3960                        astFactory.addASTChild(currentAST, returnAST);
3961                        break;
3962                }
3963                case LCURLY:
3964                {
3965                        break;
3966                }
3967                default:
3968                {
3969                        throw new NoViableAltException(LT(1), getFilename());
3970                }
3971                }
3972                }
3973                ctorHead_AST = (AST)currentAST.root;
3974                returnAST = ctorHead_AST;
3975        }
3976        
3977        public final void constructorBody() throws RecognitionException, TokenStreamException {
3978                
3979                returnAST = null;
3980                ASTPair currentAST = new ASTPair();
3981                AST constructorBody_AST = null;
3982                Token  lc = null;
3983                AST lc_AST = null;
3984                
3985                lc = LT(1);
3986                lc_AST = astFactory.create(lc);
3987                astFactory.makeASTRoot(currentAST, lc_AST);
3988                match(LCURLY);
3989                if ( inputState.guessing==0 ) {
3990                        lc_AST.setType(SLIST);
3991                }
3992                {
3993                boolean synPredMatched150 = false;
3994                if (((_tokenSet_37.member(LA(1))) && (_tokenSet_38.member(LA(2))))) {
3995                        int _m150 = mark();
3996                        synPredMatched150 = true;
3997                        inputState.guessing++;
3998                        try {
3999                                {
4000                                explicitConstructorInvocation();
4001                                }
4002                        }
4003                        catch (RecognitionException pe) {
4004                                synPredMatched150 = false;
4005                        }
4006                        rewind(_m150);
4007inputState.guessing--;
4008                }
4009                if ( synPredMatched150 ) {
4010                        explicitConstructorInvocation();
4011                        astFactory.addASTChild(currentAST, returnAST);
4012                }
4013                else if ((_tokenSet_39.member(LA(1))) && (_tokenSet_40.member(LA(2)))) {
4014                }
4015                else {
4016                        throw new NoViableAltException(LT(1), getFilename());
4017                }
4018                
4019                }
4020                {
4021                _loop152:
4022                do {
4023                        if ((_tokenSet_36.member(LA(1)))) {
4024                                statement();
4025                                astFactory.addASTChild(currentAST, returnAST);
4026                        }
4027                        else {
4028                                break _loop152;
4029                        }
4030                        
4031                } while (true);
4032                }
4033                AST tmp92_AST = null;
4034                tmp92_AST = astFactory.create(LT(1));
4035                astFactory.addASTChild(currentAST, tmp92_AST);
4036                match(RCURLY);
4037                constructorBody_AST = (AST)currentAST.root;
4038                returnAST = constructorBody_AST;
4039        }
4040        
4041        public final void explicitConstructorInvocation() throws RecognitionException, TokenStreamException {
4042                
4043                returnAST = null;
4044                ASTPair currentAST = new ASTPair();
4045                AST explicitConstructorInvocation_AST = null;
4046                Token  t = null;
4047                AST t_AST = null;
4048                Token  s = null;
4049                AST s_AST = null;
4050                Token  s1 = null;
4051                AST s1_AST = null;
4052                
4053                {
4054                if ((_tokenSet_41.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
4055                        {
4056                        switch ( LA(1)) {
4057                        case LT:
4058                        {
4059                                typeArguments(false);
4060                                astFactory.addASTChild(currentAST, returnAST);
4061                                break;
4062                        }
4063                        case LITERAL_this:
4064                        case LITERAL_super:
4065                        {
4066                                break;
4067                        }
4068                        default:
4069                        {
4070                                throw new NoViableAltException(LT(1), getFilename());
4071                        }
4072                        }
4073                        }
4074                        {
4075                        switch ( LA(1)) {
4076                        case LITERAL_this:
4077                        {
4078                                t = LT(1);
4079                                t_AST = astFactory.create(t);
4080                                astFactory.makeASTRoot(currentAST, t_AST);
4081                                match(LITERAL_this);
4082                                AST tmp93_AST = null;
4083                                tmp93_AST = astFactory.create(LT(1));
4084                                astFactory.addASTChild(currentAST, tmp93_AST);
4085                                match(LPAREN);
4086                                argList();
4087                                astFactory.addASTChild(currentAST, returnAST);
4088                                AST tmp94_AST = null;
4089                                tmp94_AST = astFactory.create(LT(1));
4090                                astFactory.addASTChild(currentAST, tmp94_AST);
4091                                match(RPAREN);
4092                                AST tmp95_AST = null;
4093                                tmp95_AST = astFactory.create(LT(1));
4094                                astFactory.addASTChild(currentAST, tmp95_AST);
4095                                match(SEMI);
4096                                if ( inputState.guessing==0 ) {
4097                                        t_AST.setType(CTOR_CALL);
4098                                }
4099                                break;
4100                        }
4101                        case LITERAL_super:
4102                        {
4103                                s = LT(1);
4104                                s_AST = astFactory.create(s);
4105                                astFactory.makeASTRoot(currentAST, s_AST);
4106                                match(LITERAL_super);
4107                                AST tmp96_AST = null;
4108                                tmp96_AST = astFactory.create(LT(1));
4109                                astFactory.addASTChild(currentAST, tmp96_AST);
4110                                match(LPAREN);
4111                                argList();
4112                                astFactory.addASTChild(currentAST, returnAST);
4113                                AST tmp97_AST = null;
4114                                tmp97_AST = astFactory.create(LT(1));
4115                                astFactory.addASTChild(currentAST, tmp97_AST);
4116                                match(RPAREN);
4117                                AST tmp98_AST = null;
4118                                tmp98_AST = astFactory.create(LT(1));
4119                                astFactory.addASTChild(currentAST, tmp98_AST);
4120                                match(SEMI);
4121                                if ( inputState.guessing==0 ) {
4122                                        s_AST.setType(SUPER_CTOR_CALL);
4123                                }
4124                                break;
4125                        }
4126                        default:
4127                        {
4128                                throw new NoViableAltException(LT(1), getFilename());
4129                        }
4130                        }
4131                        }
4132                }
4133                else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_44.member(LA(2)))) {
4134                        primaryExpression();
4135                        astFactory.addASTChild(currentAST, returnAST);
4136                        AST tmp99_AST = null;
4137                        tmp99_AST = astFactory.create(LT(1));
4138                        astFactory.addASTChild(currentAST, tmp99_AST);
4139                        match(DOT);
4140                        {
4141                        switch ( LA(1)) {
4142                        case LT:
4143                        {
4144                                typeArguments(false);
4145                                astFactory.addASTChild(currentAST, returnAST);
4146                                break;
4147                        }
4148                        case LITERAL_super:
4149                        {
4150                                break;
4151                        }
4152                        default:
4153                        {
4154                                throw new NoViableAltException(LT(1), getFilename());
4155                        }
4156                        }
4157                        }
4158                        s1 = LT(1);
4159                        s1_AST = astFactory.create(s1);
4160                        astFactory.makeASTRoot(currentAST, s1_AST);
4161                        match(LITERAL_super);
4162                        AST tmp100_AST = null;
4163                        tmp100_AST = astFactory.create(LT(1));
4164                        astFactory.addASTChild(currentAST, tmp100_AST);
4165                        match(LPAREN);
4166                        argList();
4167                        astFactory.addASTChild(currentAST, returnAST);
4168                        AST tmp101_AST = null;
4169                        tmp101_AST = astFactory.create(LT(1));
4170                        astFactory.addASTChild(currentAST, tmp101_AST);
4171                        match(RPAREN);
4172                        AST tmp102_AST = null;
4173                        tmp102_AST = astFactory.create(LT(1));
4174                        astFactory.addASTChild(currentAST, tmp102_AST);
4175                        match(SEMI);
4176                        if ( inputState.guessing==0 ) {
4177                                s1_AST.setType(SUPER_CTOR_CALL);
4178                        }
4179                }
4180                else {
4181                        throw new NoViableAltException(LT(1), getFilename());
4182                }
4183                
4184                }
4185                explicitConstructorInvocation_AST = (AST)currentAST.root;
4186                returnAST = explicitConstructorInvocation_AST;
4187        }
4188        
4189        public final void statement() throws RecognitionException, TokenStreamException {
4190                
4191                returnAST = null;
4192                ASTPair currentAST = new ASTPair();
4193                AST statement_AST = null;
4194                
4195                switch ( LA(1)) {
4196                case FINAL:
4197                case ABSTRACT:
4198                case STRICTFP:
4199                case SEMI:
4200                case LITERAL_void:
4201                case LITERAL_boolean:
4202                case LITERAL_byte:
4203                case LITERAL_char:
4204                case LITERAL_short:
4205                case LITERAL_int:
4206                case LITERAL_float:
4207                case LITERAL_long:
4208                case LITERAL_double:
4209                case IDENT:
4210                case LITERAL_private:
4211                case LITERAL_public:
4212                case LITERAL_protected:
4213                case LITERAL_static:
4214                case LITERAL_transient:
4215                case LITERAL_native:
4216                case LITERAL_synchronized:
4217                case LITERAL_volatile:
4218                case LITERAL_class:
4219                case LCURLY:
4220                case LPAREN:
4221                case LITERAL_this:
4222                case LITERAL_super:
4223                case LITERAL_if:
4224                case LITERAL_while:
4225                case LITERAL_do:
4226                case LITERAL_break:
4227                case LITERAL_continue:
4228                case LITERAL_return:
4229                case LITERAL_switch:
4230                case LITERAL_throw:
4231                case LITERAL_for:
4232                case LITERAL_default:
4233                case LITERAL_try:
4234                case PLUS:
4235                case MINUS:
4236                case INC:
4237                case DEC:
4238                case BNOT:
4239                case LNOT:
4240                case LITERAL_true:
4241                case LITERAL_false:
4242                case LITERAL_null:
4243                case LITERAL_new:
4244                case NUM_INT:
4245                case CHAR_LITERAL:
4246                case STRING_LITERAL:
4247                case NUM_FLOAT:
4248                case NUM_LONG:
4249                case NUM_DOUBLE:
4250                case AT:
4251                {
4252                        traditionalStatement();
4253                        astFactory.addASTChild(currentAST, returnAST);
4254                        statement_AST = (AST)currentAST.root;
4255                        break;
4256                }
4257                case ASSERT:
4258                {
4259                        assertStatement();
4260                        astFactory.addASTChild(currentAST, returnAST);
4261                        statement_AST = (AST)currentAST.root;
4262                        break;
4263                }
4264                default:
4265                {
4266                        throw new NoViableAltException(LT(1), getFilename());
4267                }
4268                }
4269                returnAST = statement_AST;
4270        }
4271        
4272        public final void primaryExpression() throws RecognitionException, TokenStreamException {
4273                
4274                returnAST = null;
4275                ASTPair currentAST = new ASTPair();
4276                AST primaryExpression_AST = null;
4277                Token  lbt = null;
4278                AST lbt_AST = null;
4279                
4280                switch ( LA(1)) {
4281                case IDENT:
4282                {
4283                        AST tmp103_AST = null;
4284                        tmp103_AST = astFactory.create(LT(1));
4285                        astFactory.addASTChild(currentAST, tmp103_AST);
4286                        match(IDENT);
4287                        {
4288                        boolean synPredMatched344 = false;
4289                        if (((LA(1)==LT) && (_tokenSet_18.member(LA(2))))) {
4290                                int _m344 = mark();
4291                                synPredMatched344 = true;
4292                                inputState.guessing++;
4293                                try {
4294                                        {
4295                                        typeArguments(false);
4296                                        match(DOUBLE_COLON);
4297                                        }
4298                                }
4299                                catch (RecognitionException pe) {
4300                                        synPredMatched344 = false;
4301                                }
4302                                rewind(_m344);
4303inputState.guessing--;
4304                        }
4305                        if ( synPredMatched344 ) {
4306                                typeArguments(false);
4307                                astFactory.addASTChild(currentAST, returnAST);
4308                        }
4309                        else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
4310                        }
4311                        else {
4312                                throw new NoViableAltException(LT(1), getFilename());
4313                        }
4314                        
4315                        }
4316                        primaryExpression_AST = (AST)currentAST.root;
4317                        break;
4318                }
4319                case NUM_INT:
4320                case CHAR_LITERAL:
4321                case STRING_LITERAL:
4322                case NUM_FLOAT:
4323                case NUM_LONG:
4324                case NUM_DOUBLE:
4325                {
4326                        constant();
4327                        astFactory.addASTChild(currentAST, returnAST);
4328                        primaryExpression_AST = (AST)currentAST.root;
4329                        break;
4330                }
4331                case LITERAL_true:
4332                {
4333                        AST tmp104_AST = null;
4334                        tmp104_AST = astFactory.create(LT(1));
4335                        astFactory.addASTChild(currentAST, tmp104_AST);
4336                        match(LITERAL_true);
4337                        primaryExpression_AST = (AST)currentAST.root;
4338                        break;
4339                }
4340                case LITERAL_false:
4341                {
4342                        AST tmp105_AST = null;
4343                        tmp105_AST = astFactory.create(LT(1));
4344                        astFactory.addASTChild(currentAST, tmp105_AST);
4345                        match(LITERAL_false);
4346                        primaryExpression_AST = (AST)currentAST.root;
4347                        break;
4348                }
4349                case LITERAL_this:
4350                {
4351                        AST tmp106_AST = null;
4352                        tmp106_AST = astFactory.create(LT(1));
4353                        astFactory.addASTChild(currentAST, tmp106_AST);
4354                        match(LITERAL_this);
4355                        primaryExpression_AST = (AST)currentAST.root;
4356                        break;
4357                }
4358                case LITERAL_null:
4359                {
4360                        AST tmp107_AST = null;
4361                        tmp107_AST = astFactory.create(LT(1));
4362                        astFactory.addASTChild(currentAST, tmp107_AST);
4363                        match(LITERAL_null);
4364                        primaryExpression_AST = (AST)currentAST.root;
4365                        break;
4366                }
4367                case LITERAL_new:
4368                {
4369                        newExpression();
4370                        astFactory.addASTChild(currentAST, returnAST);
4371                        primaryExpression_AST = (AST)currentAST.root;
4372                        break;
4373                }
4374                case LPAREN:
4375                {
4376                        AST tmp108_AST = null;
4377                        tmp108_AST = astFactory.create(LT(1));
4378                        astFactory.addASTChild(currentAST, tmp108_AST);
4379                        match(LPAREN);
4380                        {
4381                        boolean synPredMatched347 = false;
4382                        if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
4383                                int _m347 = mark();
4384                                synPredMatched347 = true;
4385                                inputState.guessing++;
4386                                try {
4387                                        {
4388                                        lambdaExpression();
4389                                        }
4390                                }
4391                                catch (RecognitionException pe) {
4392                                        synPredMatched347 = false;
4393                                }
4394                                rewind(_m347);
4395inputState.guessing--;
4396                        }
4397                        if ( synPredMatched347 ) {
4398                                lambdaExpression();
4399                                astFactory.addASTChild(currentAST, returnAST);
4400                        }
4401                        else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4402                                assignmentExpression();
4403                                astFactory.addASTChild(currentAST, returnAST);
4404                        }
4405                        else {
4406                                throw new NoViableAltException(LT(1), getFilename());
4407                        }
4408                        
4409                        }
4410                        AST tmp109_AST = null;
4411                        tmp109_AST = astFactory.create(LT(1));
4412                        astFactory.addASTChild(currentAST, tmp109_AST);
4413                        match(RPAREN);
4414                        primaryExpression_AST = (AST)currentAST.root;
4415                        break;
4416                }
4417                case LITERAL_super:
4418                {
4419                        AST tmp110_AST = null;
4420                        tmp110_AST = astFactory.create(LT(1));
4421                        astFactory.addASTChild(currentAST, tmp110_AST);
4422                        match(LITERAL_super);
4423                        primaryExpression_AST = (AST)currentAST.root;
4424                        break;
4425                }
4426                case LITERAL_void:
4427                case LITERAL_boolean:
4428                case LITERAL_byte:
4429                case LITERAL_char:
4430                case LITERAL_short:
4431                case LITERAL_int:
4432                case LITERAL_float:
4433                case LITERAL_long:
4434                case LITERAL_double:
4435                {
4436                        builtInType();
4437                        astFactory.addASTChild(currentAST, returnAST);
4438                        {
4439                        _loop349:
4440                        do {
4441                                if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
4442                                        lbt = LT(1);
4443                                        lbt_AST = astFactory.create(lbt);
4444                                        astFactory.makeASTRoot(currentAST, lbt_AST);
4445                                        match(LBRACK);
4446                                        if ( inputState.guessing==0 ) {
4447                                                lbt_AST.setType(ARRAY_DECLARATOR);
4448                                        }
4449                                        AST tmp111_AST = null;
4450                                        tmp111_AST = astFactory.create(LT(1));
4451                                        astFactory.addASTChild(currentAST, tmp111_AST);
4452                                        match(RBRACK);
4453                                }
4454                                else {
4455                                        break _loop349;
4456                                }
4457                                
4458                        } while (true);
4459                        }
4460                        {
4461                        if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) {
4462                                AST tmp112_AST = null;
4463                                tmp112_AST = astFactory.create(LT(1));
4464                                astFactory.makeASTRoot(currentAST, tmp112_AST);
4465                                match(DOT);
4466                                AST tmp113_AST = null;
4467                                tmp113_AST = astFactory.create(LT(1));
4468                                astFactory.addASTChild(currentAST, tmp113_AST);
4469                                match(LITERAL_class);
4470                        }
4471                        else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
4472                        }
4473                        else {
4474                                throw new NoViableAltException(LT(1), getFilename());
4475                        }
4476                        
4477                        }
4478                        primaryExpression_AST = (AST)currentAST.root;
4479                        break;
4480                }
4481                default:
4482                {
4483                        throw new NoViableAltException(LT(1), getFilename());
4484                }
4485                }
4486                returnAST = primaryExpression_AST;
4487        }
4488        
4489/** Declaration of a variable.  This can be a class/instance variable,
4490 *   or a local variable in a method.
4491    @param mods declaration mods.
4492    @param t variable declaration type.
4493    @throws RecognitionException if recognition problem occurs.
4494    @throws TokenStreamException if problem occurs while generating a stream of tokens.
4495 * It can also include possible initialization.
4496 */
4497        public final void variableDeclarator(
4498                AST mods, AST t
4499        ) throws RecognitionException, TokenStreamException {
4500                
4501                returnAST = null;
4502                ASTPair currentAST = new ASTPair();
4503                AST variableDeclarator_AST = null;
4504                Token  id = null;
4505                AST id_AST = null;
4506                AST d_AST = null;
4507                AST v_AST = null;
4508                
4509                id = LT(1);
4510                id_AST = astFactory.create(id);
4511                match(IDENT);
4512                declaratorBrackets(t);
4513                d_AST = (AST)returnAST;
4514                varInitializer();
4515                v_AST = (AST)returnAST;
4516                if ( inputState.guessing==0 ) {
4517                        variableDeclarator_AST = (AST)currentAST.root;
4518                        variableDeclarator_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(mods).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(d_AST))).add(id_AST).add(v_AST));
4519                        currentAST.root = variableDeclarator_AST;
4520                        currentAST.child = variableDeclarator_AST!=null &&variableDeclarator_AST.getFirstChild()!=null ?
4521                                variableDeclarator_AST.getFirstChild() : variableDeclarator_AST;
4522                        currentAST.advanceChildToEnd();
4523                }
4524                returnAST = variableDeclarator_AST;
4525        }
4526        
4527        public final void varInitializer() throws RecognitionException, TokenStreamException {
4528                
4529                returnAST = null;
4530                ASTPair currentAST = new ASTPair();
4531                AST varInitializer_AST = null;
4532                
4533                {
4534                switch ( LA(1)) {
4535                case ASSIGN:
4536                {
4537                        AST tmp114_AST = null;
4538                        tmp114_AST = astFactory.create(LT(1));
4539                        astFactory.makeASTRoot(currentAST, tmp114_AST);
4540                        match(ASSIGN);
4541                        initializer();
4542                        astFactory.addASTChild(currentAST, returnAST);
4543                        break;
4544                }
4545                case FINAL:
4546                case ABSTRACT:
4547                case STRICTFP:
4548                case SEMI:
4549                case LITERAL_void:
4550                case LITERAL_boolean:
4551                case LITERAL_byte:
4552                case LITERAL_char:
4553                case LITERAL_short:
4554                case LITERAL_int:
4555                case LITERAL_float:
4556                case LITERAL_long:
4557                case LITERAL_double:
4558                case IDENT:
4559                case LITERAL_private:
4560                case LITERAL_public:
4561                case LITERAL_protected:
4562                case LITERAL_static:
4563                case LITERAL_transient:
4564                case LITERAL_native:
4565                case LITERAL_synchronized:
4566                case LITERAL_volatile:
4567                case LITERAL_class:
4568                case LITERAL_interface:
4569                case LCURLY:
4570                case RCURLY:
4571                case COMMA:
4572                case LITERAL_default:
4573                case LT:
4574                case ENUM:
4575                case AT:
4576                {
4577                        break;
4578                }
4579                default:
4580                {
4581                        throw new NoViableAltException(LT(1), getFilename());
4582                }
4583                }
4584                }
4585                varInitializer_AST = (AST)currentAST.root;
4586                returnAST = varInitializer_AST;
4587        }
4588        
4589        public final void initializer() throws RecognitionException, TokenStreamException {
4590                
4591                returnAST = null;
4592                ASTPair currentAST = new ASTPair();
4593                AST initializer_AST = null;
4594                
4595                switch ( LA(1)) {
4596                case LITERAL_void:
4597                case LITERAL_boolean:
4598                case LITERAL_byte:
4599                case LITERAL_char:
4600                case LITERAL_short:
4601                case LITERAL_int:
4602                case LITERAL_float:
4603                case LITERAL_long:
4604                case LITERAL_double:
4605                case IDENT:
4606                case LPAREN:
4607                case LITERAL_this:
4608                case LITERAL_super:
4609                case PLUS:
4610                case MINUS:
4611                case INC:
4612                case DEC:
4613                case BNOT:
4614                case LNOT:
4615                case LITERAL_true:
4616                case LITERAL_false:
4617                case LITERAL_null:
4618                case LITERAL_new:
4619                case NUM_INT:
4620                case CHAR_LITERAL:
4621                case STRING_LITERAL:
4622                case NUM_FLOAT:
4623                case NUM_LONG:
4624                case NUM_DOUBLE:
4625                {
4626                        expression();
4627                        astFactory.addASTChild(currentAST, returnAST);
4628                        initializer_AST = (AST)currentAST.root;
4629                        break;
4630                }
4631                case LCURLY:
4632                {
4633                        arrayInitializer();
4634                        astFactory.addASTChild(currentAST, returnAST);
4635                        initializer_AST = (AST)currentAST.root;
4636                        break;
4637                }
4638                default:
4639                {
4640                        throw new NoViableAltException(LT(1), getFilename());
4641                }
4642                }
4643                returnAST = initializer_AST;
4644        }
4645        
4646        public final void arrayInitializer() throws RecognitionException, TokenStreamException {
4647                
4648                returnAST = null;
4649                ASTPair currentAST = new ASTPair();
4650                AST arrayInitializer_AST = null;
4651                Token  lc = null;
4652                AST lc_AST = null;
4653                
4654                lc = LT(1);
4655                lc_AST = astFactory.create(lc);
4656                astFactory.makeASTRoot(currentAST, lc_AST);
4657                match(LCURLY);
4658                if ( inputState.guessing==0 ) {
4659                        lc_AST.setType(ARRAY_INIT);
4660                }
4661                {
4662                switch ( LA(1)) {
4663                case LITERAL_void:
4664                case LITERAL_boolean:
4665                case LITERAL_byte:
4666                case LITERAL_char:
4667                case LITERAL_short:
4668                case LITERAL_int:
4669                case LITERAL_float:
4670                case LITERAL_long:
4671                case LITERAL_double:
4672                case IDENT:
4673                case LCURLY:
4674                case LPAREN:
4675                case LITERAL_this:
4676                case LITERAL_super:
4677                case PLUS:
4678                case MINUS:
4679                case INC:
4680                case DEC:
4681                case BNOT:
4682                case LNOT:
4683                case LITERAL_true:
4684                case LITERAL_false:
4685                case LITERAL_null:
4686                case LITERAL_new:
4687                case NUM_INT:
4688                case CHAR_LITERAL:
4689                case STRING_LITERAL:
4690                case NUM_FLOAT:
4691                case NUM_LONG:
4692                case NUM_DOUBLE:
4693                {
4694                        initializer();
4695                        astFactory.addASTChild(currentAST, returnAST);
4696                        {
4697                        _loop170:
4698                        do {
4699                                if ((LA(1)==COMMA) && (_tokenSet_47.member(LA(2)))) {
4700                                        AST tmp115_AST = null;
4701                                        tmp115_AST = astFactory.create(LT(1));
4702                                        astFactory.addASTChild(currentAST, tmp115_AST);
4703                                        match(COMMA);
4704                                        initializer();
4705                                        astFactory.addASTChild(currentAST, returnAST);
4706                                }
4707                                else {
4708                                        break _loop170;
4709                                }
4710                                
4711                        } while (true);
4712                        }
4713                        break;
4714                }
4715                case RCURLY:
4716                case COMMA:
4717                {
4718                        break;
4719                }
4720                default:
4721                {
4722                        throw new NoViableAltException(LT(1), getFilename());
4723                }
4724                }
4725                }
4726                {
4727                switch ( LA(1)) {
4728                case COMMA:
4729                {
4730                        AST tmp116_AST = null;
4731                        tmp116_AST = astFactory.create(LT(1));
4732                        astFactory.addASTChild(currentAST, tmp116_AST);
4733                        match(COMMA);
4734                        break;
4735                }
4736                case RCURLY:
4737                {
4738                        break;
4739                }
4740                default:
4741                {
4742                        throw new NoViableAltException(LT(1), getFilename());
4743                }
4744                }
4745                }
4746                AST tmp117_AST = null;
4747                tmp117_AST = astFactory.create(LT(1));
4748                astFactory.addASTChild(currentAST, tmp117_AST);
4749                match(RCURLY);
4750                arrayInitializer_AST = (AST)currentAST.root;
4751                returnAST = arrayInitializer_AST;
4752        }
4753        
4754        public final void expression() throws RecognitionException, TokenStreamException {
4755                
4756                returnAST = null;
4757                ASTPair currentAST = new ASTPair();
4758                AST expression_AST = null;
4759                
4760                boolean synPredMatched258 = false;
4761                if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
4762                        int _m258 = mark();
4763                        synPredMatched258 = true;
4764                        inputState.guessing++;
4765                        try {
4766                                {
4767                                lambdaExpression();
4768                                }
4769                        }
4770                        catch (RecognitionException pe) {
4771                                synPredMatched258 = false;
4772                        }
4773                        rewind(_m258);
4774inputState.guessing--;
4775                }
4776                if ( synPredMatched258 ) {
4777                        lambdaExpression();
4778                        astFactory.addASTChild(currentAST, returnAST);
4779                        expression_AST = (AST)currentAST.root;
4780                }
4781                else if (((_tokenSet_16.member(LA(1))) && (_tokenSet_18.member(LA(2))))&&(LA(1)!=RPAREN)) {
4782                        assignmentExpression();
4783                        astFactory.addASTChild(currentAST, returnAST);
4784                        if ( inputState.guessing==0 ) {
4785                                expression_AST = (AST)currentAST.root;
4786                                expression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(expression_AST));
4787                                currentAST.root = expression_AST;
4788                                currentAST.child = expression_AST!=null &&expression_AST.getFirstChild()!=null ?
4789                                        expression_AST.getFirstChild() : expression_AST;
4790                                currentAST.advanceChildToEnd();
4791                        }
4792                        expression_AST = (AST)currentAST.root;
4793                }
4794                else {
4795                        throw new NoViableAltException(LT(1), getFilename());
4796                }
4797                
4798                returnAST = expression_AST;
4799        }
4800        
4801        public final void parameterDeclaration() throws RecognitionException, TokenStreamException {
4802                
4803                returnAST = null;
4804                ASTPair currentAST = new ASTPair();
4805                AST parameterDeclaration_AST = null;
4806                AST pm_AST = null;
4807                AST t_AST = null;
4808                Token  id = null;
4809                AST id_AST = null;
4810                AST pd_AST = null;
4811                
4812                parameterModifier();
4813                pm_AST = (AST)returnAST;
4814                {
4815                if ((_tokenSet_9.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
4816                        typeSpec(false);
4817                        t_AST = (AST)returnAST;
4818                }
4819                else if ((LA(1)==IDENT) && (_tokenSet_48.member(LA(2)))) {
4820                }
4821                else {
4822                        throw new NoViableAltException(LT(1), getFilename());
4823                }
4824                
4825                }
4826                id = LT(1);
4827                id_AST = astFactory.create(id);
4828                match(IDENT);
4829                declaratorBrackets(t_AST);
4830                pd_AST = (AST)returnAST;
4831                if ( inputState.guessing==0 ) {
4832                        parameterDeclaration_AST = (AST)currentAST.root;
4833                        parameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(pd_AST))).add(id_AST));
4834                        currentAST.root = parameterDeclaration_AST;
4835                        currentAST.child = parameterDeclaration_AST!=null &&parameterDeclaration_AST.getFirstChild()!=null ?
4836                                parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST;
4837                        currentAST.advanceChildToEnd();
4838                }
4839                returnAST = parameterDeclaration_AST;
4840        }
4841        
4842        public final void variableLengthParameterDeclaration() throws RecognitionException, TokenStreamException {
4843                
4844                returnAST = null;
4845                ASTPair currentAST = new ASTPair();
4846                AST variableLengthParameterDeclaration_AST = null;
4847                AST pm_AST = null;
4848                AST t_AST = null;
4849                Token  td = null;
4850                AST td_AST = null;
4851                AST pd_AST = null;
4852                
4853                parameterModifier();
4854                pm_AST = (AST)returnAST;
4855                typeSpec(false);
4856                t_AST = (AST)returnAST;
4857                td = LT(1);
4858                td_AST = astFactory.create(td);
4859                match(ELLIPSIS);
4860                AST tmp118_AST = null;
4861                tmp118_AST = astFactory.create(LT(1));
4862                match(IDENT);
4863                declaratorBrackets(t_AST);
4864                pd_AST = (AST)returnAST;
4865                if ( inputState.guessing==0 ) {
4866                        variableLengthParameterDeclaration_AST = (AST)currentAST.root;
4867                        variableLengthParameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(pd_AST))).add(td_AST).add(tmp118_AST));
4868                        currentAST.root = variableLengthParameterDeclaration_AST;
4869                        currentAST.child = variableLengthParameterDeclaration_AST!=null &&variableLengthParameterDeclaration_AST.getFirstChild()!=null ?
4870                                variableLengthParameterDeclaration_AST.getFirstChild() : variableLengthParameterDeclaration_AST;
4871                        currentAST.advanceChildToEnd();
4872                }
4873                returnAST = variableLengthParameterDeclaration_AST;
4874        }
4875        
4876        public final void parameterModifier() throws RecognitionException, TokenStreamException {
4877                
4878                returnAST = null;
4879                ASTPair currentAST = new ASTPair();
4880                AST parameterModifier_AST = null;
4881                Token  f = null;
4882                AST f_AST = null;
4883                
4884                {
4885                _loop191:
4886                do {
4887                        if ((LA(1)==AT) && (LA(2)==IDENT)) {
4888                                annotation();
4889                                astFactory.addASTChild(currentAST, returnAST);
4890                        }
4891                        else {
4892                                break _loop191;
4893                        }
4894                        
4895                } while (true);
4896                }
4897                {
4898                switch ( LA(1)) {
4899                case FINAL:
4900                {
4901                        f = LT(1);
4902                        f_AST = astFactory.create(f);
4903                        astFactory.addASTChild(currentAST, f_AST);
4904                        match(FINAL);
4905                        break;
4906                }
4907                case LITERAL_void:
4908                case LITERAL_boolean:
4909                case LITERAL_byte:
4910                case LITERAL_char:
4911                case LITERAL_short:
4912                case LITERAL_int:
4913                case LITERAL_float:
4914                case LITERAL_long:
4915                case LITERAL_double:
4916                case IDENT:
4917                case AT:
4918                {
4919                        break;
4920                }
4921                default:
4922                {
4923                        throw new NoViableAltException(LT(1), getFilename());
4924                }
4925                }
4926                }
4927                {
4928                _loop194:
4929                do {
4930                        if ((LA(1)==AT) && (LA(2)==IDENT)) {
4931                                annotation();
4932                                astFactory.addASTChild(currentAST, returnAST);
4933                        }
4934                        else {
4935                                break _loop194;
4936                        }
4937                        
4938                } while (true);
4939                }
4940                if ( inputState.guessing==0 ) {
4941                        parameterModifier_AST = (AST)currentAST.root;
4942                        parameterModifier_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(parameterModifier_AST));
4943                        currentAST.root = parameterModifier_AST;
4944                        currentAST.child = parameterModifier_AST!=null &&parameterModifier_AST.getFirstChild()!=null ?
4945                                parameterModifier_AST.getFirstChild() : parameterModifier_AST;
4946                        currentAST.advanceChildToEnd();
4947                }
4948                parameterModifier_AST = (AST)currentAST.root;
4949                returnAST = parameterModifier_AST;
4950        }
4951        
4952        public final void catchParameterDeclaration() throws RecognitionException, TokenStreamException {
4953                
4954                returnAST = null;
4955                ASTPair currentAST = new ASTPair();
4956                AST catchParameterDeclaration_AST = null;
4957                AST pm_AST = null;
4958                AST mct_AST = null;
4959                Token  id = null;
4960                AST id_AST = null;
4961                
4962                parameterModifier();
4963                pm_AST = (AST)returnAST;
4964                multiCatchTypes();
4965                mct_AST = (AST)returnAST;
4966                id = LT(1);
4967                id_AST = astFactory.create(id);
4968                match(IDENT);
4969                if ( inputState.guessing==0 ) {
4970                        catchParameterDeclaration_AST = (AST)currentAST.root;
4971                        catchParameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(mct_AST))).add(id_AST));
4972                        currentAST.root = catchParameterDeclaration_AST;
4973                        currentAST.child = catchParameterDeclaration_AST!=null &&catchParameterDeclaration_AST.getFirstChild()!=null ?
4974                                catchParameterDeclaration_AST.getFirstChild() : catchParameterDeclaration_AST;
4975                        currentAST.advanceChildToEnd();
4976                }
4977                returnAST = catchParameterDeclaration_AST;
4978        }
4979        
4980        public final void multiCatchTypes() throws RecognitionException, TokenStreamException {
4981                
4982                returnAST = null;
4983                ASTPair currentAST = new ASTPair();
4984                AST multiCatchTypes_AST = null;
4985                
4986                typeSpec(false);
4987                astFactory.addASTChild(currentAST, returnAST);
4988                {
4989                _loop200:
4990                do {
4991                        if ((LA(1)==BOR)) {
4992                                AST tmp119_AST = null;
4993                                tmp119_AST = astFactory.create(LT(1));
4994                                astFactory.makeASTRoot(currentAST, tmp119_AST);
4995                                match(BOR);
4996                                typeSpec(false);
4997                                astFactory.addASTChild(currentAST, returnAST);
4998                        }
4999                        else {
5000                                break _loop200;
5001                        }
5002                        
5003                } while (true);
5004                }
5005                multiCatchTypes_AST = (AST)currentAST.root;
5006                returnAST = multiCatchTypes_AST;
5007        }
5008        
5009        public final void traditionalStatement() throws RecognitionException, TokenStreamException {
5010                
5011                returnAST = null;
5012                ASTPair currentAST = new ASTPair();
5013                AST traditionalStatement_AST = null;
5014                AST m_AST = null;
5015                Token  c = null;
5016                AST c_AST = null;
5017                Token  w = null;
5018                AST w_AST = null;
5019                Token  s = null;
5020                AST s_AST = null;
5021                
5022                switch ( LA(1)) {
5023                case LCURLY:
5024                {
5025                        compoundStatement();
5026                        astFactory.addASTChild(currentAST, returnAST);
5027                        traditionalStatement_AST = (AST)currentAST.root;
5028                        break;
5029                }
5030                case LITERAL_if:
5031                {
5032                        AST tmp120_AST = null;
5033                        tmp120_AST = astFactory.create(LT(1));
5034                        astFactory.makeASTRoot(currentAST, tmp120_AST);
5035                        match(LITERAL_if);
5036                        AST tmp121_AST = null;
5037                        tmp121_AST = astFactory.create(LT(1));
5038                        astFactory.addASTChild(currentAST, tmp121_AST);
5039                        match(LPAREN);
5040                        expression();
5041                        astFactory.addASTChild(currentAST, returnAST);
5042                        AST tmp122_AST = null;
5043                        tmp122_AST = astFactory.create(LT(1));
5044                        astFactory.addASTChild(currentAST, tmp122_AST);
5045                        match(RPAREN);
5046                        statement();
5047                        astFactory.addASTChild(currentAST, returnAST);
5048                        {
5049                        if ((LA(1)==LITERAL_else) && (_tokenSet_36.member(LA(2)))) {
5050                                elseStatement();
5051                                astFactory.addASTChild(currentAST, returnAST);
5052                        }
5053                        else if ((_tokenSet_49.member(LA(1))) && (_tokenSet_50.member(LA(2)))) {
5054                        }
5055                        else {
5056                                throw new NoViableAltException(LT(1), getFilename());
5057                        }
5058                        
5059                        }
5060                        traditionalStatement_AST = (AST)currentAST.root;
5061                        break;
5062                }
5063                case LITERAL_for:
5064                {
5065                        forStatement();
5066                        astFactory.addASTChild(currentAST, returnAST);
5067                        traditionalStatement_AST = (AST)currentAST.root;
5068                        break;
5069                }
5070                case LITERAL_while:
5071                {
5072                        AST tmp123_AST = null;
5073                        tmp123_AST = astFactory.create(LT(1));
5074                        astFactory.makeASTRoot(currentAST, tmp123_AST);
5075                        match(LITERAL_while);
5076                        AST tmp124_AST = null;
5077                        tmp124_AST = astFactory.create(LT(1));
5078                        astFactory.addASTChild(currentAST, tmp124_AST);
5079                        match(LPAREN);
5080                        expression();
5081                        astFactory.addASTChild(currentAST, returnAST);
5082                        AST tmp125_AST = null;
5083                        tmp125_AST = astFactory.create(LT(1));
5084                        astFactory.addASTChild(currentAST, tmp125_AST);
5085                        match(RPAREN);
5086                        statement();
5087                        astFactory.addASTChild(currentAST, returnAST);
5088                        traditionalStatement_AST = (AST)currentAST.root;
5089                        break;
5090                }
5091                case LITERAL_do:
5092                {
5093                        AST tmp126_AST = null;
5094                        tmp126_AST = astFactory.create(LT(1));
5095                        astFactory.makeASTRoot(currentAST, tmp126_AST);
5096                        match(LITERAL_do);
5097                        statement();
5098                        astFactory.addASTChild(currentAST, returnAST);
5099                        w = LT(1);
5100                        w_AST = astFactory.create(w);
5101                        astFactory.addASTChild(currentAST, w_AST);
5102                        match(LITERAL_while);
5103                        if ( inputState.guessing==0 ) {
5104                                w_AST.setType(DO_WHILE);
5105                        }
5106                        AST tmp127_AST = null;
5107                        tmp127_AST = astFactory.create(LT(1));
5108                        astFactory.addASTChild(currentAST, tmp127_AST);
5109                        match(LPAREN);
5110                        expression();
5111                        astFactory.addASTChild(currentAST, returnAST);
5112                        AST tmp128_AST = null;
5113                        tmp128_AST = astFactory.create(LT(1));
5114                        astFactory.addASTChild(currentAST, tmp128_AST);
5115                        match(RPAREN);
5116                        AST tmp129_AST = null;
5117                        tmp129_AST = astFactory.create(LT(1));
5118                        astFactory.addASTChild(currentAST, tmp129_AST);
5119                        match(SEMI);
5120                        traditionalStatement_AST = (AST)currentAST.root;
5121                        break;
5122                }
5123                case LITERAL_break:
5124                {
5125                        AST tmp130_AST = null;
5126                        tmp130_AST = astFactory.create(LT(1));
5127                        astFactory.makeASTRoot(currentAST, tmp130_AST);
5128                        match(LITERAL_break);
5129                        {
5130                        switch ( LA(1)) {
5131                        case IDENT:
5132                        {
5133                                AST tmp131_AST = null;
5134                                tmp131_AST = astFactory.create(LT(1));
5135                                astFactory.addASTChild(currentAST, tmp131_AST);
5136                                match(IDENT);
5137                                break;
5138                        }
5139                        case SEMI:
5140                        {
5141                                break;
5142                        }
5143                        default:
5144                        {
5145                                throw new NoViableAltException(LT(1), getFilename());
5146                        }
5147                        }
5148                        }
5149                        AST tmp132_AST = null;
5150                        tmp132_AST = astFactory.create(LT(1));
5151                        astFactory.addASTChild(currentAST, tmp132_AST);
5152                        match(SEMI);
5153                        traditionalStatement_AST = (AST)currentAST.root;
5154                        break;
5155                }
5156                case LITERAL_continue:
5157                {
5158                        AST tmp133_AST = null;
5159                        tmp133_AST = astFactory.create(LT(1));
5160                        astFactory.makeASTRoot(currentAST, tmp133_AST);
5161                        match(LITERAL_continue);
5162                        {
5163                        switch ( LA(1)) {
5164                        case IDENT:
5165                        {
5166                                AST tmp134_AST = null;
5167                                tmp134_AST = astFactory.create(LT(1));
5168                                astFactory.addASTChild(currentAST, tmp134_AST);
5169                                match(IDENT);
5170                                break;
5171                        }
5172                        case SEMI:
5173                        {
5174                                break;
5175                        }
5176                        default:
5177                        {
5178                                throw new NoViableAltException(LT(1), getFilename());
5179                        }
5180                        }
5181                        }
5182                        AST tmp135_AST = null;
5183                        tmp135_AST = astFactory.create(LT(1));
5184                        astFactory.addASTChild(currentAST, tmp135_AST);
5185                        match(SEMI);
5186                        traditionalStatement_AST = (AST)currentAST.root;
5187                        break;
5188                }
5189                case LITERAL_return:
5190                {
5191                        AST tmp136_AST = null;
5192                        tmp136_AST = astFactory.create(LT(1));
5193                        astFactory.makeASTRoot(currentAST, tmp136_AST);
5194                        match(LITERAL_return);
5195                        {
5196                        switch ( LA(1)) {
5197                        case LITERAL_void:
5198                        case LITERAL_boolean:
5199                        case LITERAL_byte:
5200                        case LITERAL_char:
5201                        case LITERAL_short:
5202                        case LITERAL_int:
5203                        case LITERAL_float:
5204                        case LITERAL_long:
5205                        case LITERAL_double:
5206                        case IDENT:
5207                        case LPAREN:
5208                        case LITERAL_this:
5209                        case LITERAL_super:
5210                        case PLUS:
5211                        case MINUS:
5212                        case INC:
5213                        case DEC:
5214                        case BNOT:
5215                        case LNOT:
5216                        case LITERAL_true:
5217                        case LITERAL_false:
5218                        case LITERAL_null:
5219                        case LITERAL_new:
5220                        case NUM_INT:
5221                        case CHAR_LITERAL:
5222                        case STRING_LITERAL:
5223                        case NUM_FLOAT:
5224                        case NUM_LONG:
5225                        case NUM_DOUBLE:
5226                        {
5227                                expression();
5228                                astFactory.addASTChild(currentAST, returnAST);
5229                                break;
5230                        }
5231                        case SEMI:
5232                        {
5233                                break;
5234                        }
5235                        default:
5236                        {
5237                                throw new NoViableAltException(LT(1), getFilename());
5238                        }
5239                        }
5240                        }
5241                        AST tmp137_AST = null;
5242                        tmp137_AST = astFactory.create(LT(1));
5243                        astFactory.addASTChild(currentAST, tmp137_AST);
5244                        match(SEMI);
5245                        traditionalStatement_AST = (AST)currentAST.root;
5246                        break;
5247                }
5248                case LITERAL_switch:
5249                {
5250                        AST tmp138_AST = null;
5251                        tmp138_AST = astFactory.create(LT(1));
5252                        astFactory.makeASTRoot(currentAST, tmp138_AST);
5253                        match(LITERAL_switch);
5254                        AST tmp139_AST = null;
5255                        tmp139_AST = astFactory.create(LT(1));
5256                        astFactory.addASTChild(currentAST, tmp139_AST);
5257                        match(LPAREN);
5258                        expression();
5259                        astFactory.addASTChild(currentAST, returnAST);
5260                        AST tmp140_AST = null;
5261                        tmp140_AST = astFactory.create(LT(1));
5262                        astFactory.addASTChild(currentAST, tmp140_AST);
5263                        match(RPAREN);
5264                        AST tmp141_AST = null;
5265                        tmp141_AST = astFactory.create(LT(1));
5266                        astFactory.addASTChild(currentAST, tmp141_AST);
5267                        match(LCURLY);
5268                        {
5269                        _loop216:
5270                        do {
5271                                if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default)) {
5272                                        casesGroup();
5273                                        astFactory.addASTChild(currentAST, returnAST);
5274                                }
5275                                else {
5276                                        break _loop216;
5277                                }
5278                                
5279                        } while (true);
5280                        }
5281                        AST tmp142_AST = null;
5282                        tmp142_AST = astFactory.create(LT(1));
5283                        astFactory.addASTChild(currentAST, tmp142_AST);
5284                        match(RCURLY);
5285                        traditionalStatement_AST = (AST)currentAST.root;
5286                        break;
5287                }
5288                case LITERAL_try:
5289                {
5290                        tryBlock();
5291                        astFactory.addASTChild(currentAST, returnAST);
5292                        traditionalStatement_AST = (AST)currentAST.root;
5293                        break;
5294                }
5295                case LITERAL_throw:
5296                {
5297                        AST tmp143_AST = null;
5298                        tmp143_AST = astFactory.create(LT(1));
5299                        astFactory.makeASTRoot(currentAST, tmp143_AST);
5300                        match(LITERAL_throw);
5301                        expression();
5302                        astFactory.addASTChild(currentAST, returnAST);
5303                        AST tmp144_AST = null;
5304                        tmp144_AST = astFactory.create(LT(1));
5305                        astFactory.addASTChild(currentAST, tmp144_AST);
5306                        match(SEMI);
5307                        traditionalStatement_AST = (AST)currentAST.root;
5308                        break;
5309                }
5310                case SEMI:
5311                {
5312                        s = LT(1);
5313                        s_AST = astFactory.create(s);
5314                        astFactory.addASTChild(currentAST, s_AST);
5315                        match(SEMI);
5316                        if ( inputState.guessing==0 ) {
5317                                s_AST.setType(EMPTY_STAT);
5318                        }
5319                        traditionalStatement_AST = (AST)currentAST.root;
5320                        break;
5321                }
5322                default:
5323                        boolean synPredMatched209 = false;
5324                        if (((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2))))) {
5325                                int _m209 = mark();
5326                                synPredMatched209 = true;
5327                                inputState.guessing++;
5328                                try {
5329                                        {
5330                                        declaration();
5331                                        }
5332                                }
5333                                catch (RecognitionException pe) {
5334                                        synPredMatched209 = false;
5335                                }
5336                                rewind(_m209);
5337inputState.guessing--;
5338                        }
5339                        if ( synPredMatched209 ) {
5340                                declaration();
5341                                astFactory.addASTChild(currentAST, returnAST);
5342                                AST tmp145_AST = null;
5343                                tmp145_AST = astFactory.create(LT(1));
5344                                astFactory.addASTChild(currentAST, tmp145_AST);
5345                                match(SEMI);
5346                                traditionalStatement_AST = (AST)currentAST.root;
5347                        }
5348                        else if (((_tokenSet_16.member(LA(1))) && (_tokenSet_53.member(LA(2))))&&(LA(2) != COLON)) {
5349                                expression();
5350                                astFactory.addASTChild(currentAST, returnAST);
5351                                {
5352                                if ((LA(1)==SEMI) && (_tokenSet_49.member(LA(2)))) {
5353                                        AST tmp146_AST = null;
5354                                        tmp146_AST = astFactory.create(LT(1));
5355                                        astFactory.addASTChild(currentAST, tmp146_AST);
5356                                        match(SEMI);
5357                                }
5358                                else if ((_tokenSet_49.member(LA(1))) && (_tokenSet_50.member(LA(2)))) {
5359                                }
5360                                else {
5361                                        throw new NoViableAltException(LT(1), getFilename());
5362                                }
5363                                
5364                                }
5365                                traditionalStatement_AST = (AST)currentAST.root;
5366                        }
5367                        else if ((_tokenSet_54.member(LA(1))) && (_tokenSet_55.member(LA(2)))) {
5368                                modifiers();
5369                                m_AST = (AST)returnAST;
5370                                classDefinition(m_AST);
5371                                astFactory.addASTChild(currentAST, returnAST);
5372                                traditionalStatement_AST = (AST)currentAST.root;
5373                        }
5374                        else if ((LA(1)==IDENT) && (LA(2)==COLON)) {
5375                                AST tmp147_AST = null;
5376                                tmp147_AST = astFactory.create(LT(1));
5377                                astFactory.addASTChild(currentAST, tmp147_AST);
5378                                match(IDENT);
5379                                c = LT(1);
5380                                c_AST = astFactory.create(c);
5381                                astFactory.makeASTRoot(currentAST, c_AST);
5382                                match(COLON);
5383                                if ( inputState.guessing==0 ) {
5384                                        c_AST.setType(LABELED_STAT);
5385                                }
5386                                statement();
5387                                astFactory.addASTChild(currentAST, returnAST);
5388                                traditionalStatement_AST = (AST)currentAST.root;
5389                        }
5390                        else if ((LA(1)==LITERAL_synchronized) && (LA(2)==LPAREN)) {
5391                                AST tmp148_AST = null;
5392                                tmp148_AST = astFactory.create(LT(1));
5393                                astFactory.makeASTRoot(currentAST, tmp148_AST);
5394                                match(LITERAL_synchronized);
5395                                AST tmp149_AST = null;
5396                                tmp149_AST = astFactory.create(LT(1));
5397                                astFactory.addASTChild(currentAST, tmp149_AST);
5398                                match(LPAREN);
5399                                expression();
5400                                astFactory.addASTChild(currentAST, returnAST);
5401                                AST tmp150_AST = null;
5402                                tmp150_AST = astFactory.create(LT(1));
5403                                astFactory.addASTChild(currentAST, tmp150_AST);
5404                                match(RPAREN);
5405                                compoundStatement();
5406                                astFactory.addASTChild(currentAST, returnAST);
5407                                traditionalStatement_AST = (AST)currentAST.root;
5408                        }
5409                else {
5410                        throw new NoViableAltException(LT(1), getFilename());
5411                }
5412                }
5413                returnAST = traditionalStatement_AST;
5414        }
5415        
5416        public final void assertStatement() throws RecognitionException, TokenStreamException {
5417                
5418                returnAST = null;
5419                ASTPair currentAST = new ASTPair();
5420                AST assertStatement_AST = null;
5421                
5422                AST tmp151_AST = null;
5423                tmp151_AST = astFactory.create(LT(1));
5424                astFactory.makeASTRoot(currentAST, tmp151_AST);
5425                match(ASSERT);
5426                expression();
5427                astFactory.addASTChild(currentAST, returnAST);
5428                {
5429                switch ( LA(1)) {
5430                case COLON:
5431                {
5432                        AST tmp152_AST = null;
5433                        tmp152_AST = astFactory.create(LT(1));
5434                        astFactory.addASTChild(currentAST, tmp152_AST);
5435                        match(COLON);
5436                        expression();
5437                        astFactory.addASTChild(currentAST, returnAST);
5438                        break;
5439                }
5440                case SEMI:
5441                {
5442                        break;
5443                }
5444                default:
5445                {
5446                        throw new NoViableAltException(LT(1), getFilename());
5447                }
5448                }
5449                }
5450                AST tmp153_AST = null;
5451                tmp153_AST = astFactory.create(LT(1));
5452                astFactory.addASTChild(currentAST, tmp153_AST);
5453                match(SEMI);
5454                assertStatement_AST = (AST)currentAST.root;
5455                returnAST = assertStatement_AST;
5456        }
5457        
5458        public final void elseStatement() throws RecognitionException, TokenStreamException {
5459                
5460                returnAST = null;
5461                ASTPair currentAST = new ASTPair();
5462                AST elseStatement_AST = null;
5463                
5464                AST tmp154_AST = null;
5465                tmp154_AST = astFactory.create(LT(1));
5466                astFactory.makeASTRoot(currentAST, tmp154_AST);
5467                match(LITERAL_else);
5468                statement();
5469                astFactory.addASTChild(currentAST, returnAST);
5470                elseStatement_AST = (AST)currentAST.root;
5471                returnAST = elseStatement_AST;
5472        }
5473        
5474        public final void forStatement() throws RecognitionException, TokenStreamException {
5475                
5476                returnAST = null;
5477                ASTPair currentAST = new ASTPair();
5478                AST forStatement_AST = null;
5479                Token  f = null;
5480                AST f_AST = null;
5481                
5482                f = LT(1);
5483                f_AST = astFactory.create(f);
5484                astFactory.makeASTRoot(currentAST, f_AST);
5485                match(LITERAL_for);
5486                AST tmp155_AST = null;
5487                tmp155_AST = astFactory.create(LT(1));
5488                astFactory.addASTChild(currentAST, tmp155_AST);
5489                match(LPAREN);
5490                {
5491                boolean synPredMatched220 = false;
5492                if (((_tokenSet_56.member(LA(1))) && (_tokenSet_57.member(LA(2))))) {
5493                        int _m220 = mark();
5494                        synPredMatched220 = true;
5495                        inputState.guessing++;
5496                        try {
5497                                {
5498                                forInit();
5499                                match(SEMI);
5500                                }
5501                        }
5502                        catch (RecognitionException pe) {
5503                                synPredMatched220 = false;
5504                        }
5505                        rewind(_m220);
5506inputState.guessing--;
5507                }
5508                if ( synPredMatched220 ) {
5509                        traditionalForClause();
5510                        astFactory.addASTChild(currentAST, returnAST);
5511                }
5512                else if ((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2)))) {
5513                        forEachClause();
5514                        astFactory.addASTChild(currentAST, returnAST);
5515                }
5516                else {
5517                        throw new NoViableAltException(LT(1), getFilename());
5518                }
5519                
5520                }
5521                AST tmp156_AST = null;
5522                tmp156_AST = astFactory.create(LT(1));
5523                astFactory.addASTChild(currentAST, tmp156_AST);
5524                match(RPAREN);
5525                statement();
5526                astFactory.addASTChild(currentAST, returnAST);
5527                forStatement_AST = (AST)currentAST.root;
5528                returnAST = forStatement_AST;
5529        }
5530        
5531        public final void casesGroup() throws RecognitionException, TokenStreamException {
5532                
5533                returnAST = null;
5534                ASTPair currentAST = new ASTPair();
5535                AST casesGroup_AST = null;
5536                
5537                {
5538                int _cnt227=0;
5539                _loop227:
5540                do {
5541                        if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default) && (_tokenSet_58.member(LA(2)))) {
5542                                aCase();
5543                                astFactory.addASTChild(currentAST, returnAST);
5544                        }
5545                        else {
5546                                if ( _cnt227>=1 ) { break _loop227; } else {throw new NoViableAltException(LT(1), getFilename());}
5547                        }
5548                        
5549                        _cnt227++;
5550                } while (true);
5551                }
5552                {
5553                if ((_tokenSet_36.member(LA(1))) && (_tokenSet_59.member(LA(2)))) {
5554                        caseSList();
5555                        astFactory.addASTChild(currentAST, returnAST);
5556                }
5557                else if ((_tokenSet_60.member(LA(1))) && (_tokenSet_49.member(LA(2)))) {
5558                }
5559                else {
5560                        throw new NoViableAltException(LT(1), getFilename());
5561                }
5562                
5563                }
5564                if ( inputState.guessing==0 ) {
5565                        casesGroup_AST = (AST)currentAST.root;
5566                        casesGroup_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CASE_GROUP,"CASE_GROUP")).add(casesGroup_AST));
5567                        currentAST.root = casesGroup_AST;
5568                        currentAST.child = casesGroup_AST!=null &&casesGroup_AST.getFirstChild()!=null ?
5569                                casesGroup_AST.getFirstChild() : casesGroup_AST;
5570                        currentAST.advanceChildToEnd();
5571                }
5572                casesGroup_AST = (AST)currentAST.root;
5573                returnAST = casesGroup_AST;
5574        }
5575        
5576        public final void tryBlock() throws RecognitionException, TokenStreamException {
5577                
5578                returnAST = null;
5579                ASTPair currentAST = new ASTPair();
5580                AST tryBlock_AST = null;
5581                
5582                AST tmp157_AST = null;
5583                tmp157_AST = astFactory.create(LT(1));
5584                astFactory.makeASTRoot(currentAST, tmp157_AST);
5585                match(LITERAL_try);
5586                {
5587                switch ( LA(1)) {
5588                case LPAREN:
5589                {
5590                        resourceSpecification();
5591                        astFactory.addASTChild(currentAST, returnAST);
5592                        break;
5593                }
5594                case LCURLY:
5595                {
5596                        break;
5597                }
5598                default:
5599                {
5600                        throw new NoViableAltException(LT(1), getFilename());
5601                }
5602                }
5603                }
5604                compoundStatement();
5605                astFactory.addASTChild(currentAST, returnAST);
5606                {
5607                _loop245:
5608                do {
5609                        if ((LA(1)==LITERAL_catch)) {
5610                                handler();
5611                                astFactory.addASTChild(currentAST, returnAST);
5612                        }
5613                        else {
5614                                break _loop245;
5615                        }
5616                        
5617                } while (true);
5618                }
5619                {
5620                switch ( LA(1)) {
5621                case LITERAL_finally:
5622                {
5623                        finallyHandler();
5624                        astFactory.addASTChild(currentAST, returnAST);
5625                        break;
5626                }
5627                case FINAL:
5628                case ABSTRACT:
5629                case STRICTFP:
5630                case SEMI:
5631                case LITERAL_void:
5632                case LITERAL_boolean:
5633                case LITERAL_byte:
5634                case LITERAL_char:
5635                case LITERAL_short:
5636                case LITERAL_int:
5637                case LITERAL_float:
5638                case LITERAL_long:
5639                case LITERAL_double:
5640                case IDENT:
5641                case LITERAL_private:
5642                case LITERAL_public:
5643                case LITERAL_protected:
5644                case LITERAL_static:
5645                case LITERAL_transient:
5646                case LITERAL_native:
5647                case LITERAL_synchronized:
5648                case LITERAL_volatile:
5649                case LITERAL_class:
5650                case LCURLY:
5651                case RCURLY:
5652                case LPAREN:
5653                case RPAREN:
5654                case LITERAL_this:
5655                case LITERAL_super:
5656                case COLON:
5657                case LITERAL_if:
5658                case LITERAL_while:
5659                case LITERAL_do:
5660                case LITERAL_break:
5661                case LITERAL_continue:
5662                case LITERAL_return:
5663                case LITERAL_switch:
5664                case LITERAL_throw:
5665                case LITERAL_for:
5666                case LITERAL_else:
5667                case LITERAL_case:
5668                case LITERAL_default:
5669                case LITERAL_try:
5670                case PLUS:
5671                case MINUS:
5672                case INC:
5673                case DEC:
5674                case BNOT:
5675                case LNOT:
5676                case LITERAL_true:
5677                case LITERAL_false:
5678                case LITERAL_null:
5679                case LITERAL_new:
5680                case NUM_INT:
5681                case CHAR_LITERAL:
5682                case STRING_LITERAL:
5683                case NUM_FLOAT:
5684                case NUM_LONG:
5685                case NUM_DOUBLE:
5686                case ASSERT:
5687                case AT:
5688                {
5689                        break;
5690                }
5691                default:
5692                {
5693                        throw new NoViableAltException(LT(1), getFilename());
5694                }
5695                }
5696                }
5697                tryBlock_AST = (AST)currentAST.root;
5698                returnAST = tryBlock_AST;
5699        }
5700        
5701        public final void forInit() throws RecognitionException, TokenStreamException {
5702                
5703                returnAST = null;
5704                ASTPair currentAST = new ASTPair();
5705                AST forInit_AST = null;
5706                
5707                {
5708                boolean synPredMatched237 = false;
5709                if (((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2))))) {
5710                        int _m237 = mark();
5711                        synPredMatched237 = true;
5712                        inputState.guessing++;
5713                        try {
5714                                {
5715                                declaration();
5716                                }
5717                        }
5718                        catch (RecognitionException pe) {
5719                                synPredMatched237 = false;
5720                        }
5721                        rewind(_m237);
5722inputState.guessing--;
5723                }
5724                if ( synPredMatched237 ) {
5725                        declaration();
5726                        astFactory.addASTChild(currentAST, returnAST);
5727                }
5728                else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_61.member(LA(2)))) {
5729                        expressionList();
5730                        astFactory.addASTChild(currentAST, returnAST);
5731                }
5732                else if ((LA(1)==SEMI)) {
5733                }
5734                else {
5735                        throw new NoViableAltException(LT(1), getFilename());
5736                }
5737                
5738                }
5739                if ( inputState.guessing==0 ) {
5740                        forInit_AST = (AST)currentAST.root;
5741                        forInit_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_INIT,"FOR_INIT")).add(forInit_AST));
5742                        currentAST.root = forInit_AST;
5743                        currentAST.child = forInit_AST!=null &&forInit_AST.getFirstChild()!=null ?
5744                                forInit_AST.getFirstChild() : forInit_AST;
5745                        currentAST.advanceChildToEnd();
5746                }
5747                forInit_AST = (AST)currentAST.root;
5748                returnAST = forInit_AST;
5749        }
5750        
5751        public final void traditionalForClause() throws RecognitionException, TokenStreamException {
5752                
5753                returnAST = null;
5754                ASTPair currentAST = new ASTPair();
5755                AST traditionalForClause_AST = null;
5756                
5757                forInit();
5758                astFactory.addASTChild(currentAST, returnAST);
5759                AST tmp158_AST = null;
5760                tmp158_AST = astFactory.create(LT(1));
5761                astFactory.addASTChild(currentAST, tmp158_AST);
5762                match(SEMI);
5763                forCond();
5764                astFactory.addASTChild(currentAST, returnAST);
5765                AST tmp159_AST = null;
5766                tmp159_AST = astFactory.create(LT(1));
5767                astFactory.addASTChild(currentAST, tmp159_AST);
5768                match(SEMI);
5769                forIter();
5770                astFactory.addASTChild(currentAST, returnAST);
5771                traditionalForClause_AST = (AST)currentAST.root;
5772                returnAST = traditionalForClause_AST;
5773        }
5774        
5775        public final void forEachClause() throws RecognitionException, TokenStreamException {
5776                
5777                returnAST = null;
5778                ASTPair currentAST = new ASTPair();
5779                AST forEachClause_AST = null;
5780                
5781                forEachDeclarator();
5782                astFactory.addASTChild(currentAST, returnAST);
5783                AST tmp160_AST = null;
5784                tmp160_AST = astFactory.create(LT(1));
5785                astFactory.addASTChild(currentAST, tmp160_AST);
5786                match(COLON);
5787                expression();
5788                astFactory.addASTChild(currentAST, returnAST);
5789                if ( inputState.guessing==0 ) {
5790                        forEachClause_AST = (AST)currentAST.root;
5791                        forEachClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_EACH_CLAUSE,"FOR_EACH_CLAUSE")).add(forEachClause_AST));
5792                        currentAST.root = forEachClause_AST;
5793                        currentAST.child = forEachClause_AST!=null &&forEachClause_AST.getFirstChild()!=null ?
5794                                forEachClause_AST.getFirstChild() : forEachClause_AST;
5795                        currentAST.advanceChildToEnd();
5796                }
5797                forEachClause_AST = (AST)currentAST.root;
5798                returnAST = forEachClause_AST;
5799        }
5800        
5801        public final void forCond() throws RecognitionException, TokenStreamException {
5802                
5803                returnAST = null;
5804                ASTPair currentAST = new ASTPair();
5805                AST forCond_AST = null;
5806                
5807                {
5808                switch ( LA(1)) {
5809                case LITERAL_void:
5810                case LITERAL_boolean:
5811                case LITERAL_byte:
5812                case LITERAL_char:
5813                case LITERAL_short:
5814                case LITERAL_int:
5815                case LITERAL_float:
5816                case LITERAL_long:
5817                case LITERAL_double:
5818                case IDENT:
5819                case LPAREN:
5820                case LITERAL_this:
5821                case LITERAL_super:
5822                case PLUS:
5823                case MINUS:
5824                case INC:
5825                case DEC:
5826                case BNOT:
5827                case LNOT:
5828                case LITERAL_true:
5829                case LITERAL_false:
5830                case LITERAL_null:
5831                case LITERAL_new:
5832                case NUM_INT:
5833                case CHAR_LITERAL:
5834                case STRING_LITERAL:
5835                case NUM_FLOAT:
5836                case NUM_LONG:
5837                case NUM_DOUBLE:
5838                {
5839                        expression();
5840                        astFactory.addASTChild(currentAST, returnAST);
5841                        break;
5842                }
5843                case SEMI:
5844                {
5845                        break;
5846                }
5847                default:
5848                {
5849                        throw new NoViableAltException(LT(1), getFilename());
5850                }
5851                }
5852                }
5853                if ( inputState.guessing==0 ) {
5854                        forCond_AST = (AST)currentAST.root;
5855                        forCond_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_CONDITION,"FOR_CONDITION")).add(forCond_AST));
5856                        currentAST.root = forCond_AST;
5857                        currentAST.child = forCond_AST!=null &&forCond_AST.getFirstChild()!=null ?
5858                                forCond_AST.getFirstChild() : forCond_AST;
5859                        currentAST.advanceChildToEnd();
5860                }
5861                forCond_AST = (AST)currentAST.root;
5862                returnAST = forCond_AST;
5863        }
5864        
5865        public final void forIter() throws RecognitionException, TokenStreamException {
5866                
5867                returnAST = null;
5868                ASTPair currentAST = new ASTPair();
5869                AST forIter_AST = null;
5870                
5871                {
5872                switch ( LA(1)) {
5873                case LITERAL_void:
5874                case LITERAL_boolean:
5875                case LITERAL_byte:
5876                case LITERAL_char:
5877                case LITERAL_short:
5878                case LITERAL_int:
5879                case LITERAL_float:
5880                case LITERAL_long:
5881                case LITERAL_double:
5882                case IDENT:
5883                case LPAREN:
5884                case LITERAL_this:
5885                case LITERAL_super:
5886                case PLUS:
5887                case MINUS:
5888                case INC:
5889                case DEC:
5890                case BNOT:
5891                case LNOT:
5892                case LITERAL_true:
5893                case LITERAL_false:
5894                case LITERAL_null:
5895                case LITERAL_new:
5896                case NUM_INT:
5897                case CHAR_LITERAL:
5898                case STRING_LITERAL:
5899                case NUM_FLOAT:
5900                case NUM_LONG:
5901                case NUM_DOUBLE:
5902                {
5903                        expressionList();
5904                        astFactory.addASTChild(currentAST, returnAST);
5905                        break;
5906                }
5907                case RPAREN:
5908                {
5909                        break;
5910                }
5911                default:
5912                {
5913                        throw new NoViableAltException(LT(1), getFilename());
5914                }
5915                }
5916                }
5917                if ( inputState.guessing==0 ) {
5918                        forIter_AST = (AST)currentAST.root;
5919                        forIter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_ITERATOR,"FOR_ITERATOR")).add(forIter_AST));
5920                        currentAST.root = forIter_AST;
5921                        currentAST.child = forIter_AST!=null &&forIter_AST.getFirstChild()!=null ?
5922                                forIter_AST.getFirstChild() : forIter_AST;
5923                        currentAST.advanceChildToEnd();
5924                }
5925                forIter_AST = (AST)currentAST.root;
5926                returnAST = forIter_AST;
5927        }
5928        
5929        public final void forEachDeclarator() throws RecognitionException, TokenStreamException {
5930                
5931                returnAST = null;
5932                ASTPair currentAST = new ASTPair();
5933                AST forEachDeclarator_AST = null;
5934                AST m_AST = null;
5935                AST t_AST = null;
5936                Token  id = null;
5937                AST id_AST = null;
5938                AST d_AST = null;
5939                
5940                modifiers();
5941                m_AST = (AST)returnAST;
5942                typeSpec(false);
5943                t_AST = (AST)returnAST;
5944                id = LT(1);
5945                id_AST = astFactory.create(id);
5946                match(IDENT);
5947                declaratorBrackets(t_AST);
5948                d_AST = (AST)returnAST;
5949                if ( inputState.guessing==0 ) {
5950                        forEachDeclarator_AST = (AST)currentAST.root;
5951                        forEachDeclarator_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(m_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(d_AST))).add(id_AST));
5952                        currentAST.root = forEachDeclarator_AST;
5953                        currentAST.child = forEachDeclarator_AST!=null &&forEachDeclarator_AST.getFirstChild()!=null ?
5954                                forEachDeclarator_AST.getFirstChild() : forEachDeclarator_AST;
5955                        currentAST.advanceChildToEnd();
5956                }
5957                returnAST = forEachDeclarator_AST;
5958        }
5959        
5960        public final void aCase() throws RecognitionException, TokenStreamException {
5961                
5962                returnAST = null;
5963                ASTPair currentAST = new ASTPair();
5964                AST aCase_AST = null;
5965                
5966                {
5967                switch ( LA(1)) {
5968                case LITERAL_case:
5969                {
5970                        AST tmp161_AST = null;
5971                        tmp161_AST = astFactory.create(LT(1));
5972                        astFactory.makeASTRoot(currentAST, tmp161_AST);
5973                        match(LITERAL_case);
5974                        expression();
5975                        astFactory.addASTChild(currentAST, returnAST);
5976                        break;
5977                }
5978                case LITERAL_default:
5979                {
5980                        AST tmp162_AST = null;
5981                        tmp162_AST = astFactory.create(LT(1));
5982                        astFactory.makeASTRoot(currentAST, tmp162_AST);
5983                        match(LITERAL_default);
5984                        break;
5985                }
5986                default:
5987                {
5988                        throw new NoViableAltException(LT(1), getFilename());
5989                }
5990                }
5991                }
5992                AST tmp163_AST = null;
5993                tmp163_AST = astFactory.create(LT(1));
5994                astFactory.addASTChild(currentAST, tmp163_AST);
5995                match(COLON);
5996                aCase_AST = (AST)currentAST.root;
5997                returnAST = aCase_AST;
5998        }
5999        
6000        public final void caseSList() throws RecognitionException, TokenStreamException {
6001                
6002                returnAST = null;
6003                ASTPair currentAST = new ASTPair();
6004                AST caseSList_AST = null;
6005                
6006                {
6007                int _cnt233=0;
6008                _loop233:
6009                do {
6010                        if (((_tokenSet_36.member(LA(1))) && (_tokenSet_59.member(LA(2))))&&(LA(1)!=LITERAL_default)) {
6011                                statement();
6012                                astFactory.addASTChild(currentAST, returnAST);
6013                        }
6014                        else {
6015                                if ( _cnt233>=1 ) { break _loop233; } else {throw new NoViableAltException(LT(1), getFilename());}
6016                        }
6017                        
6018                        _cnt233++;
6019                } while (true);
6020                }
6021                if ( inputState.guessing==0 ) {
6022                        caseSList_AST = (AST)currentAST.root;
6023                        caseSList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SLIST,"SLIST")).add(caseSList_AST));
6024                        currentAST.root = caseSList_AST;
6025                        currentAST.child = caseSList_AST!=null &&caseSList_AST.getFirstChild()!=null ?
6026                                caseSList_AST.getFirstChild() : caseSList_AST;
6027                        currentAST.advanceChildToEnd();
6028                }
6029                caseSList_AST = (AST)currentAST.root;
6030                returnAST = caseSList_AST;
6031        }
6032        
6033        public final void expressionList() throws RecognitionException, TokenStreamException {
6034                
6035                returnAST = null;
6036                ASTPair currentAST = new ASTPair();
6037                AST expressionList_AST = null;
6038                
6039                expression();
6040                astFactory.addASTChild(currentAST, returnAST);
6041                {
6042                _loop261:
6043                do {
6044                        if ((LA(1)==COMMA)) {
6045                                AST tmp164_AST = null;
6046                                tmp164_AST = astFactory.create(LT(1));
6047                                astFactory.addASTChild(currentAST, tmp164_AST);
6048                                match(COMMA);
6049                                expression();
6050                                astFactory.addASTChild(currentAST, returnAST);
6051                        }
6052                        else {
6053                                break _loop261;
6054                        }
6055                        
6056                } while (true);
6057                }
6058                if ( inputState.guessing==0 ) {
6059                        expressionList_AST = (AST)currentAST.root;
6060                        expressionList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ELIST,"ELIST")).add(expressionList_AST));
6061                        currentAST.root = expressionList_AST;
6062                        currentAST.child = expressionList_AST!=null &&expressionList_AST.getFirstChild()!=null ?
6063                                expressionList_AST.getFirstChild() : expressionList_AST;
6064                        currentAST.advanceChildToEnd();
6065                }
6066                expressionList_AST = (AST)currentAST.root;
6067                returnAST = expressionList_AST;
6068        }
6069        
6070        public final void resourceSpecification() throws RecognitionException, TokenStreamException {
6071                
6072                returnAST = null;
6073                ASTPair currentAST = new ASTPair();
6074                AST resourceSpecification_AST = null;
6075                
6076                AST tmp165_AST = null;
6077                tmp165_AST = astFactory.create(LT(1));
6078                astFactory.addASTChild(currentAST, tmp165_AST);
6079                match(LPAREN);
6080                resources();
6081                astFactory.addASTChild(currentAST, returnAST);
6082                {
6083                switch ( LA(1)) {
6084                case SEMI:
6085                {
6086                        AST tmp166_AST = null;
6087                        tmp166_AST = astFactory.create(LT(1));
6088                        astFactory.addASTChild(currentAST, tmp166_AST);
6089                        match(SEMI);
6090                        break;
6091                }
6092                case RPAREN:
6093                {
6094                        break;
6095                }
6096                default:
6097                {
6098                        throw new NoViableAltException(LT(1), getFilename());
6099                }
6100                }
6101                }
6102                AST tmp167_AST = null;
6103                tmp167_AST = astFactory.create(LT(1));
6104                astFactory.addASTChild(currentAST, tmp167_AST);
6105                match(RPAREN);
6106                if ( inputState.guessing==0 ) {
6107                        resourceSpecification_AST = (AST)currentAST.root;
6108                        resourceSpecification_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCE_SPECIFICATION,"RESOURCE_SPECIFICATION")).add(resourceSpecification_AST));
6109                        currentAST.root = resourceSpecification_AST;
6110                        currentAST.child = resourceSpecification_AST!=null &&resourceSpecification_AST.getFirstChild()!=null ?
6111                                resourceSpecification_AST.getFirstChild() : resourceSpecification_AST;
6112                        currentAST.advanceChildToEnd();
6113                }
6114                resourceSpecification_AST = (AST)currentAST.root;
6115                returnAST = resourceSpecification_AST;
6116        }
6117        
6118        public final void handler() throws RecognitionException, TokenStreamException {
6119                
6120                returnAST = null;
6121                ASTPair currentAST = new ASTPair();
6122                AST handler_AST = null;
6123                
6124                AST tmp168_AST = null;
6125                tmp168_AST = astFactory.create(LT(1));
6126                astFactory.makeASTRoot(currentAST, tmp168_AST);
6127                match(LITERAL_catch);
6128                AST tmp169_AST = null;
6129                tmp169_AST = astFactory.create(LT(1));
6130                astFactory.addASTChild(currentAST, tmp169_AST);
6131                match(LPAREN);
6132                catchParameterDeclaration();
6133                astFactory.addASTChild(currentAST, returnAST);
6134                AST tmp170_AST = null;
6135                tmp170_AST = astFactory.create(LT(1));
6136                astFactory.addASTChild(currentAST, tmp170_AST);
6137                match(RPAREN);
6138                compoundStatement();
6139                astFactory.addASTChild(currentAST, returnAST);
6140                handler_AST = (AST)currentAST.root;
6141                returnAST = handler_AST;
6142        }
6143        
6144        public final void finallyHandler() throws RecognitionException, TokenStreamException {
6145                
6146                returnAST = null;
6147                ASTPair currentAST = new ASTPair();
6148                AST finallyHandler_AST = null;
6149                
6150                AST tmp171_AST = null;
6151                tmp171_AST = astFactory.create(LT(1));
6152                astFactory.makeASTRoot(currentAST, tmp171_AST);
6153                match(LITERAL_finally);
6154                compoundStatement();
6155                astFactory.addASTChild(currentAST, returnAST);
6156                finallyHandler_AST = (AST)currentAST.root;
6157                returnAST = finallyHandler_AST;
6158        }
6159        
6160        public final void resources() throws RecognitionException, TokenStreamException {
6161                
6162                returnAST = null;
6163                ASTPair currentAST = new ASTPair();
6164                AST resources_AST = null;
6165                
6166                resource();
6167                astFactory.addASTChild(currentAST, returnAST);
6168                {
6169                _loop251:
6170                do {
6171                        if ((LA(1)==SEMI) && (_tokenSet_51.member(LA(2)))) {
6172                                AST tmp172_AST = null;
6173                                tmp172_AST = astFactory.create(LT(1));
6174                                astFactory.addASTChild(currentAST, tmp172_AST);
6175                                match(SEMI);
6176                                resource();
6177                                astFactory.addASTChild(currentAST, returnAST);
6178                        }
6179                        else {
6180                                break _loop251;
6181                        }
6182                        
6183                } while (true);
6184                }
6185                if ( inputState.guessing==0 ) {
6186                        resources_AST = (AST)currentAST.root;
6187                        resources_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCES,"RESOURCES")).add(resources_AST));
6188                        currentAST.root = resources_AST;
6189                        currentAST.child = resources_AST!=null &&resources_AST.getFirstChild()!=null ?
6190                                resources_AST.getFirstChild() : resources_AST;
6191                        currentAST.advanceChildToEnd();
6192                }
6193                resources_AST = (AST)currentAST.root;
6194                returnAST = resources_AST;
6195        }
6196        
6197        public final void resource() throws RecognitionException, TokenStreamException {
6198                
6199                returnAST = null;
6200                ASTPair currentAST = new ASTPair();
6201                AST resource_AST = null;
6202                
6203                modifiers();
6204                astFactory.addASTChild(currentAST, returnAST);
6205                typeSpec(true);
6206                astFactory.addASTChild(currentAST, returnAST);
6207                AST tmp173_AST = null;
6208                tmp173_AST = astFactory.create(LT(1));
6209                astFactory.addASTChild(currentAST, tmp173_AST);
6210                match(IDENT);
6211                resource_assign();
6212                astFactory.addASTChild(currentAST, returnAST);
6213                if ( inputState.guessing==0 ) {
6214                        resource_AST = (AST)currentAST.root;
6215                        resource_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCE,"RESOURCE")).add(resource_AST));
6216                        currentAST.root = resource_AST;
6217                        currentAST.child = resource_AST!=null &&resource_AST.getFirstChild()!=null ?
6218                                resource_AST.getFirstChild() : resource_AST;
6219                        currentAST.advanceChildToEnd();
6220                }
6221                resource_AST = (AST)currentAST.root;
6222                returnAST = resource_AST;
6223        }
6224        
6225        public final void resource_assign() throws RecognitionException, TokenStreamException {
6226                
6227                returnAST = null;
6228                ASTPair currentAST = new ASTPair();
6229                AST resource_assign_AST = null;
6230                
6231                AST tmp174_AST = null;
6232                tmp174_AST = astFactory.create(LT(1));
6233                astFactory.makeASTRoot(currentAST, tmp174_AST);
6234                match(ASSIGN);
6235                expression();
6236                astFactory.addASTChild(currentAST, returnAST);
6237                resource_assign_AST = (AST)currentAST.root;
6238                returnAST = resource_assign_AST;
6239        }
6240        
6241        public final void lambdaExpression() throws RecognitionException, TokenStreamException {
6242                
6243                returnAST = null;
6244                ASTPair currentAST = new ASTPair();
6245                AST lambdaExpression_AST = null;
6246                
6247                lambdaParameters();
6248                astFactory.addASTChild(currentAST, returnAST);
6249                AST tmp175_AST = null;
6250                tmp175_AST = astFactory.create(LT(1));
6251                astFactory.makeASTRoot(currentAST, tmp175_AST);
6252                match(LAMBDA);
6253                lambdaBody();
6254                astFactory.addASTChild(currentAST, returnAST);
6255                lambdaExpression_AST = (AST)currentAST.root;
6256                returnAST = lambdaExpression_AST;
6257        }
6258        
6259        public final void assignmentExpression() throws RecognitionException, TokenStreamException {
6260                
6261                returnAST = null;
6262                ASTPair currentAST = new ASTPair();
6263                AST assignmentExpression_AST = null;
6264                
6265                conditionalExpression();
6266                astFactory.addASTChild(currentAST, returnAST);
6267                {
6268                switch ( LA(1)) {
6269                case ASSIGN:
6270                case PLUS_ASSIGN:
6271                case MINUS_ASSIGN:
6272                case STAR_ASSIGN:
6273                case DIV_ASSIGN:
6274                case MOD_ASSIGN:
6275                case SR_ASSIGN:
6276                case BSR_ASSIGN:
6277                case SL_ASSIGN:
6278                case BAND_ASSIGN:
6279                case BXOR_ASSIGN:
6280                case BOR_ASSIGN:
6281                {
6282                        {
6283                        switch ( LA(1)) {
6284                        case ASSIGN:
6285                        {
6286                                AST tmp176_AST = null;
6287                                tmp176_AST = astFactory.create(LT(1));
6288                                astFactory.makeASTRoot(currentAST, tmp176_AST);
6289                                match(ASSIGN);
6290                                break;
6291                        }
6292                        case PLUS_ASSIGN:
6293                        {
6294                                AST tmp177_AST = null;
6295                                tmp177_AST = astFactory.create(LT(1));
6296                                astFactory.makeASTRoot(currentAST, tmp177_AST);
6297                                match(PLUS_ASSIGN);
6298                                break;
6299                        }
6300                        case MINUS_ASSIGN:
6301                        {
6302                                AST tmp178_AST = null;
6303                                tmp178_AST = astFactory.create(LT(1));
6304                                astFactory.makeASTRoot(currentAST, tmp178_AST);
6305                                match(MINUS_ASSIGN);
6306                                break;
6307                        }
6308                        case STAR_ASSIGN:
6309                        {
6310                                AST tmp179_AST = null;
6311                                tmp179_AST = astFactory.create(LT(1));
6312                                astFactory.makeASTRoot(currentAST, tmp179_AST);
6313                                match(STAR_ASSIGN);
6314                                break;
6315                        }
6316                        case DIV_ASSIGN:
6317                        {
6318                                AST tmp180_AST = null;
6319                                tmp180_AST = astFactory.create(LT(1));
6320                                astFactory.makeASTRoot(currentAST, tmp180_AST);
6321                                match(DIV_ASSIGN);
6322                                break;
6323                        }
6324                        case MOD_ASSIGN:
6325                        {
6326                                AST tmp181_AST = null;
6327                                tmp181_AST = astFactory.create(LT(1));
6328                                astFactory.makeASTRoot(currentAST, tmp181_AST);
6329                                match(MOD_ASSIGN);
6330                                break;
6331                        }
6332                        case SR_ASSIGN:
6333                        {
6334                                AST tmp182_AST = null;
6335                                tmp182_AST = astFactory.create(LT(1));
6336                                astFactory.makeASTRoot(currentAST, tmp182_AST);
6337                                match(SR_ASSIGN);
6338                                break;
6339                        }
6340                        case BSR_ASSIGN:
6341                        {
6342                                AST tmp183_AST = null;
6343                                tmp183_AST = astFactory.create(LT(1));
6344                                astFactory.makeASTRoot(currentAST, tmp183_AST);
6345                                match(BSR_ASSIGN);
6346                                break;
6347                        }
6348                        case SL_ASSIGN:
6349                        {
6350                                AST tmp184_AST = null;
6351                                tmp184_AST = astFactory.create(LT(1));
6352                                astFactory.makeASTRoot(currentAST, tmp184_AST);
6353                                match(SL_ASSIGN);
6354                                break;
6355                        }
6356                        case BAND_ASSIGN:
6357                        {
6358                                AST tmp185_AST = null;
6359                                tmp185_AST = astFactory.create(LT(1));
6360                                astFactory.makeASTRoot(currentAST, tmp185_AST);
6361                                match(BAND_ASSIGN);
6362                                break;
6363                        }
6364                        case BXOR_ASSIGN:
6365                        {
6366                                AST tmp186_AST = null;
6367                                tmp186_AST = astFactory.create(LT(1));
6368                                astFactory.makeASTRoot(currentAST, tmp186_AST);
6369                                match(BXOR_ASSIGN);
6370                                break;
6371                        }
6372                        case BOR_ASSIGN:
6373                        {
6374                                AST tmp187_AST = null;
6375                                tmp187_AST = astFactory.create(LT(1));
6376                                astFactory.makeASTRoot(currentAST, tmp187_AST);
6377                                match(BOR_ASSIGN);
6378                                break;
6379                        }
6380                        default:
6381                        {
6382                                throw new NoViableAltException(LT(1), getFilename());
6383                        }
6384                        }
6385                        }
6386                        {
6387                        boolean synPredMatched267 = false;
6388                        if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
6389                                int _m267 = mark();
6390                                synPredMatched267 = true;
6391                                inputState.guessing++;
6392                                try {
6393                                        {
6394                                        lambdaExpression();
6395                                        }
6396                                }
6397                                catch (RecognitionException pe) {
6398                                        synPredMatched267 = false;
6399                                }
6400                                rewind(_m267);
6401inputState.guessing--;
6402                        }
6403                        if ( synPredMatched267 ) {
6404                                lambdaExpression();
6405                                astFactory.addASTChild(currentAST, returnAST);
6406                        }
6407                        else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_18.member(LA(2)))) {
6408                                assignmentExpression();
6409                                astFactory.addASTChild(currentAST, returnAST);
6410                        }
6411                        else {
6412                                throw new NoViableAltException(LT(1), getFilename());
6413                        }
6414                        
6415                        }
6416                        break;
6417                }
6418                case FINAL:
6419                case ABSTRACT:
6420                case STRICTFP:
6421                case SEMI:
6422                case RBRACK:
6423                case LITERAL_void:
6424                case LITERAL_boolean:
6425                case LITERAL_byte:
6426                case LITERAL_char:
6427                case LITERAL_short:
6428                case LITERAL_int:
6429                case LITERAL_float:
6430                case LITERAL_long:
6431                case LITERAL_double:
6432                case IDENT:
6433                case LITERAL_private:
6434                case LITERAL_public:
6435                case LITERAL_protected:
6436                case LITERAL_static:
6437                case LITERAL_transient:
6438                case LITERAL_native:
6439                case LITERAL_synchronized:
6440                case LITERAL_volatile:
6441                case LITERAL_class:
6442                case LITERAL_interface:
6443                case LCURLY:
6444                case RCURLY:
6445                case COMMA:
6446                case LPAREN:
6447                case RPAREN:
6448                case LITERAL_this:
6449                case LITERAL_super:
6450                case COLON:
6451                case LITERAL_if:
6452                case LITERAL_while:
6453                case LITERAL_do:
6454                case LITERAL_break:
6455                case LITERAL_continue:
6456                case LITERAL_return:
6457                case LITERAL_switch:
6458                case LITERAL_throw:
6459                case LITERAL_for:
6460                case LITERAL_else:
6461                case LITERAL_case:
6462                case LITERAL_default:
6463                case LITERAL_try:
6464                case LT:
6465                case PLUS:
6466                case MINUS:
6467                case INC:
6468                case DEC:
6469                case BNOT:
6470                case LNOT:
6471                case LITERAL_true:
6472                case LITERAL_false:
6473                case LITERAL_null:
6474                case LITERAL_new:
6475                case NUM_INT:
6476                case CHAR_LITERAL:
6477                case STRING_LITERAL:
6478                case NUM_FLOAT:
6479                case NUM_LONG:
6480                case NUM_DOUBLE:
6481                case ASSERT:
6482                case ENUM:
6483                case AT:
6484                {
6485                        break;
6486                }
6487                default:
6488                {
6489                        throw new NoViableAltException(LT(1), getFilename());
6490                }
6491                }
6492                }
6493                assignmentExpression_AST = (AST)currentAST.root;
6494                returnAST = assignmentExpression_AST;
6495        }
6496        
6497        public final void logicalOrExpression() throws RecognitionException, TokenStreamException {
6498                
6499                returnAST = null;
6500                ASTPair currentAST = new ASTPair();
6501                AST logicalOrExpression_AST = null;
6502                
6503                logicalAndExpression();
6504                astFactory.addASTChild(currentAST, returnAST);
6505                {
6506                _loop278:
6507                do {
6508                        if ((LA(1)==LOR)) {
6509                                AST tmp188_AST = null;
6510                                tmp188_AST = astFactory.create(LT(1));
6511                                astFactory.makeASTRoot(currentAST, tmp188_AST);
6512                                match(LOR);
6513                                logicalAndExpression();
6514                                astFactory.addASTChild(currentAST, returnAST);
6515                        }
6516                        else {
6517                                break _loop278;
6518                        }
6519                        
6520                } while (true);
6521                }
6522                logicalOrExpression_AST = (AST)currentAST.root;
6523                returnAST = logicalOrExpression_AST;
6524        }
6525        
6526        public final void logicalAndExpression() throws RecognitionException, TokenStreamException {
6527                
6528                returnAST = null;
6529                ASTPair currentAST = new ASTPair();
6530                AST logicalAndExpression_AST = null;
6531                
6532                inclusiveOrExpression();
6533                astFactory.addASTChild(currentAST, returnAST);
6534                {
6535                _loop281:
6536                do {
6537                        if ((LA(1)==LAND)) {
6538                                AST tmp189_AST = null;
6539                                tmp189_AST = astFactory.create(LT(1));
6540                                astFactory.makeASTRoot(currentAST, tmp189_AST);
6541                                match(LAND);
6542                                inclusiveOrExpression();
6543                                astFactory.addASTChild(currentAST, returnAST);
6544                        }
6545                        else {
6546                                break _loop281;
6547                        }
6548                        
6549                } while (true);
6550                }
6551                logicalAndExpression_AST = (AST)currentAST.root;
6552                returnAST = logicalAndExpression_AST;
6553        }
6554        
6555        public final void inclusiveOrExpression() throws RecognitionException, TokenStreamException {
6556                
6557                returnAST = null;
6558                ASTPair currentAST = new ASTPair();
6559                AST inclusiveOrExpression_AST = null;
6560                
6561                exclusiveOrExpression();
6562                astFactory.addASTChild(currentAST, returnAST);
6563                {
6564                _loop284:
6565                do {
6566                        if ((LA(1)==BOR)) {
6567                                AST tmp190_AST = null;
6568                                tmp190_AST = astFactory.create(LT(1));
6569                                astFactory.makeASTRoot(currentAST, tmp190_AST);
6570                                match(BOR);
6571                                exclusiveOrExpression();
6572                                astFactory.addASTChild(currentAST, returnAST);
6573                        }
6574                        else {
6575                                break _loop284;
6576                        }
6577                        
6578                } while (true);
6579                }
6580                inclusiveOrExpression_AST = (AST)currentAST.root;
6581                returnAST = inclusiveOrExpression_AST;
6582        }
6583        
6584        public final void exclusiveOrExpression() throws RecognitionException, TokenStreamException {
6585                
6586                returnAST = null;
6587                ASTPair currentAST = new ASTPair();
6588                AST exclusiveOrExpression_AST = null;
6589                
6590                andExpression();
6591                astFactory.addASTChild(currentAST, returnAST);
6592                {
6593                _loop287:
6594                do {
6595                        if ((LA(1)==BXOR)) {
6596                                AST tmp191_AST = null;
6597                                tmp191_AST = astFactory.create(LT(1));
6598                                astFactory.makeASTRoot(currentAST, tmp191_AST);
6599                                match(BXOR);
6600                                andExpression();
6601                                astFactory.addASTChild(currentAST, returnAST);
6602                        }
6603                        else {
6604                                break _loop287;
6605                        }
6606                        
6607                } while (true);
6608                }
6609                exclusiveOrExpression_AST = (AST)currentAST.root;
6610                returnAST = exclusiveOrExpression_AST;
6611        }
6612        
6613        public final void andExpression() throws RecognitionException, TokenStreamException {
6614                
6615                returnAST = null;
6616                ASTPair currentAST = new ASTPair();
6617                AST andExpression_AST = null;
6618                
6619                equalityExpression();
6620                astFactory.addASTChild(currentAST, returnAST);
6621                {
6622                _loop290:
6623                do {
6624                        if ((LA(1)==BAND)) {
6625                                AST tmp192_AST = null;
6626                                tmp192_AST = astFactory.create(LT(1));
6627                                astFactory.makeASTRoot(currentAST, tmp192_AST);
6628                                match(BAND);
6629                                equalityExpression();
6630                                astFactory.addASTChild(currentAST, returnAST);
6631                        }
6632                        else {
6633                                break _loop290;
6634                        }
6635                        
6636                } while (true);
6637                }
6638                andExpression_AST = (AST)currentAST.root;
6639                returnAST = andExpression_AST;
6640        }
6641        
6642        public final void equalityExpression() throws RecognitionException, TokenStreamException {
6643                
6644                returnAST = null;
6645                ASTPair currentAST = new ASTPair();
6646                AST equalityExpression_AST = null;
6647                
6648                relationalExpression();
6649                astFactory.addASTChild(currentAST, returnAST);
6650                {
6651                _loop294:
6652                do {
6653                        if ((LA(1)==NOT_EQUAL||LA(1)==EQUAL)) {
6654                                {
6655                                switch ( LA(1)) {
6656                                case NOT_EQUAL:
6657                                {
6658                                        AST tmp193_AST = null;
6659                                        tmp193_AST = astFactory.create(LT(1));
6660                                        astFactory.makeASTRoot(currentAST, tmp193_AST);
6661                                        match(NOT_EQUAL);
6662                                        break;
6663                                }
6664                                case EQUAL:
6665                                {
6666                                        AST tmp194_AST = null;
6667                                        tmp194_AST = astFactory.create(LT(1));
6668                                        astFactory.makeASTRoot(currentAST, tmp194_AST);
6669                                        match(EQUAL);
6670                                        break;
6671                                }
6672                                default:
6673                                {
6674                                        throw new NoViableAltException(LT(1), getFilename());
6675                                }
6676                                }
6677                                }
6678                                relationalExpression();
6679                                astFactory.addASTChild(currentAST, returnAST);
6680                        }
6681                        else {
6682                                break _loop294;
6683                        }
6684                        
6685                } while (true);
6686                }
6687                equalityExpression_AST = (AST)currentAST.root;
6688                returnAST = equalityExpression_AST;
6689        }
6690        
6691        public final void relationalExpression() throws RecognitionException, TokenStreamException {
6692                
6693                returnAST = null;
6694                ASTPair currentAST = new ASTPair();
6695                AST relationalExpression_AST = null;
6696                
6697                shiftExpression();
6698                astFactory.addASTChild(currentAST, returnAST);
6699                {
6700                switch ( LA(1)) {
6701                case LITERAL_instanceof:
6702                {
6703                        AST tmp195_AST = null;
6704                        tmp195_AST = astFactory.create(LT(1));
6705                        astFactory.makeASTRoot(currentAST, tmp195_AST);
6706                        match(LITERAL_instanceof);
6707                        typeSpec(true);
6708                        astFactory.addASTChild(currentAST, returnAST);
6709                        break;
6710                }
6711                case FINAL:
6712                case ABSTRACT:
6713                case STRICTFP:
6714                case SEMI:
6715                case RBRACK:
6716                case LITERAL_void:
6717                case LITERAL_boolean:
6718                case LITERAL_byte:
6719                case LITERAL_char:
6720                case LITERAL_short:
6721                case LITERAL_int:
6722                case LITERAL_float:
6723                case LITERAL_long:
6724                case LITERAL_double:
6725                case IDENT:
6726                case LITERAL_private:
6727                case LITERAL_public:
6728                case LITERAL_protected:
6729                case LITERAL_static:
6730                case LITERAL_transient:
6731                case LITERAL_native:
6732                case LITERAL_synchronized:
6733                case LITERAL_volatile:
6734                case LITERAL_class:
6735                case LITERAL_interface:
6736                case LCURLY:
6737                case RCURLY:
6738                case COMMA:
6739                case LPAREN:
6740                case RPAREN:
6741                case LITERAL_this:
6742                case LITERAL_super:
6743                case ASSIGN:
6744                case COLON:
6745                case LITERAL_if:
6746                case LITERAL_while:
6747                case LITERAL_do:
6748                case LITERAL_break:
6749                case LITERAL_continue:
6750                case LITERAL_return:
6751                case LITERAL_switch:
6752                case LITERAL_throw:
6753                case LITERAL_for:
6754                case LITERAL_else:
6755                case LITERAL_case:
6756                case LITERAL_default:
6757                case LITERAL_try:
6758                case PLUS_ASSIGN:
6759                case MINUS_ASSIGN:
6760                case STAR_ASSIGN:
6761                case DIV_ASSIGN:
6762                case MOD_ASSIGN:
6763                case SR_ASSIGN:
6764                case BSR_ASSIGN:
6765                case SL_ASSIGN:
6766                case BAND_ASSIGN:
6767                case BXOR_ASSIGN:
6768                case BOR_ASSIGN:
6769                case QUESTION:
6770                case LOR:
6771                case LAND:
6772                case BOR:
6773                case BXOR:
6774                case BAND:
6775                case NOT_EQUAL:
6776                case EQUAL:
6777                case LT:
6778                case GT:
6779                case LE:
6780                case GE:
6781                case PLUS:
6782                case MINUS:
6783                case INC:
6784                case DEC:
6785                case BNOT:
6786                case LNOT:
6787                case LITERAL_true:
6788                case LITERAL_false:
6789                case LITERAL_null:
6790                case LITERAL_new:
6791                case NUM_INT:
6792                case CHAR_LITERAL:
6793                case STRING_LITERAL:
6794                case NUM_FLOAT:
6795                case NUM_LONG:
6796                case NUM_DOUBLE:
6797                case ASSERT:
6798                case ENUM:
6799                case AT:
6800                {
6801                        break;
6802                }
6803                default:
6804                {
6805                        throw new NoViableAltException(LT(1), getFilename());
6806                }
6807                }
6808                }
6809                {
6810                {
6811                _loop300:
6812                do {
6813                        if (((LA(1) >= LT && LA(1) <= GE)) && (_tokenSet_16.member(LA(2)))) {
6814                                {
6815                                switch ( LA(1)) {
6816                                case LT:
6817                                {
6818                                        AST tmp196_AST = null;
6819                                        tmp196_AST = astFactory.create(LT(1));
6820                                        astFactory.makeASTRoot(currentAST, tmp196_AST);
6821                                        match(LT);
6822                                        break;
6823                                }
6824                                case GT:
6825                                {
6826                                        AST tmp197_AST = null;
6827                                        tmp197_AST = astFactory.create(LT(1));
6828                                        astFactory.makeASTRoot(currentAST, tmp197_AST);
6829                                        match(GT);
6830                                        break;
6831                                }
6832                                case LE:
6833                                {
6834                                        AST tmp198_AST = null;
6835                                        tmp198_AST = astFactory.create(LT(1));
6836                                        astFactory.makeASTRoot(currentAST, tmp198_AST);
6837                                        match(LE);
6838                                        break;
6839                                }
6840                                case GE:
6841                                {
6842                                        AST tmp199_AST = null;
6843                                        tmp199_AST = astFactory.create(LT(1));
6844                                        astFactory.makeASTRoot(currentAST, tmp199_AST);
6845                                        match(GE);
6846                                        break;
6847                                }
6848                                default:
6849                                {
6850                                        throw new NoViableAltException(LT(1), getFilename());
6851                                }
6852                                }
6853                                }
6854                                shiftExpression();
6855                                astFactory.addASTChild(currentAST, returnAST);
6856                        }
6857                        else {
6858                                break _loop300;
6859                        }
6860                        
6861                } while (true);
6862                }
6863                }
6864                relationalExpression_AST = (AST)currentAST.root;
6865                returnAST = relationalExpression_AST;
6866        }
6867        
6868        public final void shiftExpression() throws RecognitionException, TokenStreamException {
6869                
6870                returnAST = null;
6871                ASTPair currentAST = new ASTPair();
6872                AST shiftExpression_AST = null;
6873                
6874                additiveExpression();
6875                astFactory.addASTChild(currentAST, returnAST);
6876                {
6877                _loop304:
6878                do {
6879                        if (((LA(1) >= SL && LA(1) <= BSR))) {
6880                                {
6881                                switch ( LA(1)) {
6882                                case SL:
6883                                {
6884                                        AST tmp200_AST = null;
6885                                        tmp200_AST = astFactory.create(LT(1));
6886                                        astFactory.makeASTRoot(currentAST, tmp200_AST);
6887                                        match(SL);
6888                                        break;
6889                                }
6890                                case SR:
6891                                {
6892                                        AST tmp201_AST = null;
6893                                        tmp201_AST = astFactory.create(LT(1));
6894                                        astFactory.makeASTRoot(currentAST, tmp201_AST);
6895                                        match(SR);
6896                                        break;
6897                                }
6898                                case BSR:
6899                                {
6900                                        AST tmp202_AST = null;
6901                                        tmp202_AST = astFactory.create(LT(1));
6902                                        astFactory.makeASTRoot(currentAST, tmp202_AST);
6903                                        match(BSR);
6904                                        break;
6905                                }
6906                                default:
6907                                {
6908                                        throw new NoViableAltException(LT(1), getFilename());
6909                                }
6910                                }
6911                                }
6912                                additiveExpression();
6913                                astFactory.addASTChild(currentAST, returnAST);
6914                        }
6915                        else {
6916                                break _loop304;
6917                        }
6918                        
6919                } while (true);
6920                }
6921                shiftExpression_AST = (AST)currentAST.root;
6922                returnAST = shiftExpression_AST;
6923        }
6924        
6925        public final void additiveExpression() throws RecognitionException, TokenStreamException {
6926                
6927                returnAST = null;
6928                ASTPair currentAST = new ASTPair();
6929                AST additiveExpression_AST = null;
6930                
6931                multiplicativeExpression();
6932                astFactory.addASTChild(currentAST, returnAST);
6933                {
6934                _loop308:
6935                do {
6936                        if ((LA(1)==PLUS||LA(1)==MINUS) && (_tokenSet_16.member(LA(2)))) {
6937                                {
6938                                switch ( LA(1)) {
6939                                case PLUS:
6940                                {
6941                                        AST tmp203_AST = null;
6942                                        tmp203_AST = astFactory.create(LT(1));
6943                                        astFactory.makeASTRoot(currentAST, tmp203_AST);
6944                                        match(PLUS);
6945                                        break;
6946                                }
6947                                case MINUS:
6948                                {
6949                                        AST tmp204_AST = null;
6950                                        tmp204_AST = astFactory.create(LT(1));
6951                                        astFactory.makeASTRoot(currentAST, tmp204_AST);
6952                                        match(MINUS);
6953                                        break;
6954                                }
6955                                default:
6956                                {
6957                                        throw new NoViableAltException(LT(1), getFilename());
6958                                }
6959                                }
6960                                }
6961                                multiplicativeExpression();
6962                                astFactory.addASTChild(currentAST, returnAST);
6963                        }
6964                        else {
6965                                break _loop308;
6966                        }
6967                        
6968                } while (true);
6969                }
6970                additiveExpression_AST = (AST)currentAST.root;
6971                returnAST = additiveExpression_AST;
6972        }
6973        
6974        public final void multiplicativeExpression() throws RecognitionException, TokenStreamException {
6975                
6976                returnAST = null;
6977                ASTPair currentAST = new ASTPair();
6978                AST multiplicativeExpression_AST = null;
6979                
6980                unaryExpression();
6981                astFactory.addASTChild(currentAST, returnAST);
6982                {
6983                _loop312:
6984                do {
6985                        if ((_tokenSet_62.member(LA(1)))) {
6986                                {
6987                                switch ( LA(1)) {
6988                                case STAR:
6989                                {
6990                                        AST tmp205_AST = null;
6991                                        tmp205_AST = astFactory.create(LT(1));
6992                                        astFactory.makeASTRoot(currentAST, tmp205_AST);
6993                                        match(STAR);
6994                                        break;
6995                                }
6996                                case DIV:
6997                                {
6998                                        AST tmp206_AST = null;
6999                                        tmp206_AST = astFactory.create(LT(1));
7000                                        astFactory.makeASTRoot(currentAST, tmp206_AST);
7001                                        match(DIV);
7002                                        break;
7003                                }
7004                                case MOD:
7005                                {
7006                                        AST tmp207_AST = null;
7007                                        tmp207_AST = astFactory.create(LT(1));
7008                                        astFactory.makeASTRoot(currentAST, tmp207_AST);
7009                                        match(MOD);
7010                                        break;
7011                                }
7012                                default:
7013                                {
7014                                        throw new NoViableAltException(LT(1), getFilename());
7015                                }
7016                                }
7017                                }
7018                                unaryExpression();
7019                                astFactory.addASTChild(currentAST, returnAST);
7020                        }
7021                        else {
7022                                break _loop312;
7023                        }
7024                        
7025                } while (true);
7026                }
7027                multiplicativeExpression_AST = (AST)currentAST.root;
7028                returnAST = multiplicativeExpression_AST;
7029        }
7030        
7031        public final void unaryExpression() throws RecognitionException, TokenStreamException {
7032                
7033                returnAST = null;
7034                ASTPair currentAST = new ASTPair();
7035                AST unaryExpression_AST = null;
7036                
7037                switch ( LA(1)) {
7038                case INC:
7039                {
7040                        AST tmp208_AST = null;
7041                        tmp208_AST = astFactory.create(LT(1));
7042                        astFactory.makeASTRoot(currentAST, tmp208_AST);
7043                        match(INC);
7044                        unaryExpression();
7045                        astFactory.addASTChild(currentAST, returnAST);
7046                        unaryExpression_AST = (AST)currentAST.root;
7047                        break;
7048                }
7049                case DEC:
7050                {
7051                        AST tmp209_AST = null;
7052                        tmp209_AST = astFactory.create(LT(1));
7053                        astFactory.makeASTRoot(currentAST, tmp209_AST);
7054                        match(DEC);
7055                        unaryExpression();
7056                        astFactory.addASTChild(currentAST, returnAST);
7057                        unaryExpression_AST = (AST)currentAST.root;
7058                        break;
7059                }
7060                case MINUS:
7061                {
7062                        AST tmp210_AST = null;
7063                        tmp210_AST = astFactory.create(LT(1));
7064                        astFactory.makeASTRoot(currentAST, tmp210_AST);
7065                        match(MINUS);
7066                        if ( inputState.guessing==0 ) {
7067                                tmp210_AST.setType(UNARY_MINUS);
7068                        }
7069                        unaryExpression();
7070                        astFactory.addASTChild(currentAST, returnAST);
7071                        unaryExpression_AST = (AST)currentAST.root;
7072                        break;
7073                }
7074                case PLUS:
7075                {
7076                        AST tmp211_AST = null;
7077                        tmp211_AST = astFactory.create(LT(1));
7078                        astFactory.makeASTRoot(currentAST, tmp211_AST);
7079                        match(PLUS);
7080                        if ( inputState.guessing==0 ) {
7081                                tmp211_AST.setType(UNARY_PLUS);
7082                        }
7083                        unaryExpression();
7084                        astFactory.addASTChild(currentAST, returnAST);
7085                        unaryExpression_AST = (AST)currentAST.root;
7086                        break;
7087                }
7088                case LITERAL_void:
7089                case LITERAL_boolean:
7090                case LITERAL_byte:
7091                case LITERAL_char:
7092                case LITERAL_short:
7093                case LITERAL_int:
7094                case LITERAL_float:
7095                case LITERAL_long:
7096                case LITERAL_double:
7097                case IDENT:
7098                case LPAREN:
7099                case LITERAL_this:
7100                case LITERAL_super:
7101                case BNOT:
7102                case LNOT:
7103                case LITERAL_true:
7104                case LITERAL_false:
7105                case LITERAL_null:
7106                case LITERAL_new:
7107                case NUM_INT:
7108                case CHAR_LITERAL:
7109                case STRING_LITERAL:
7110                case NUM_FLOAT:
7111                case NUM_LONG:
7112                case NUM_DOUBLE:
7113                {
7114                        unaryExpressionNotPlusMinus();
7115                        astFactory.addASTChild(currentAST, returnAST);
7116                        unaryExpression_AST = (AST)currentAST.root;
7117                        break;
7118                }
7119                default:
7120                {
7121                        throw new NoViableAltException(LT(1), getFilename());
7122                }
7123                }
7124                returnAST = unaryExpression_AST;
7125        }
7126        
7127        public final void unaryExpressionNotPlusMinus() throws RecognitionException, TokenStreamException {
7128                
7129                returnAST = null;
7130                ASTPair currentAST = new ASTPair();
7131                AST unaryExpressionNotPlusMinus_AST = null;
7132                Token  lpb = null;
7133                AST lpb_AST = null;
7134                Token  lp = null;
7135                AST lp_AST = null;
7136                Token  lpl = null;
7137                AST lpl_AST = null;
7138                
7139                switch ( LA(1)) {
7140                case BNOT:
7141                {
7142                        AST tmp212_AST = null;
7143                        tmp212_AST = astFactory.create(LT(1));
7144                        astFactory.makeASTRoot(currentAST, tmp212_AST);
7145                        match(BNOT);
7146                        unaryExpression();
7147                        astFactory.addASTChild(currentAST, returnAST);
7148                        unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
7149                        break;
7150                }
7151                case LNOT:
7152                {
7153                        AST tmp213_AST = null;
7154                        tmp213_AST = astFactory.create(LT(1));
7155                        astFactory.makeASTRoot(currentAST, tmp213_AST);
7156                        match(LNOT);
7157                        unaryExpression();
7158                        astFactory.addASTChild(currentAST, returnAST);
7159                        unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
7160                        break;
7161                }
7162                case LITERAL_void:
7163                case LITERAL_boolean:
7164                case LITERAL_byte:
7165                case LITERAL_char:
7166                case LITERAL_short:
7167                case LITERAL_int:
7168                case LITERAL_float:
7169                case LITERAL_long:
7170                case LITERAL_double:
7171                case IDENT:
7172                case LPAREN:
7173                case LITERAL_this:
7174                case LITERAL_super:
7175                case LITERAL_true:
7176                case LITERAL_false:
7177                case LITERAL_null:
7178                case LITERAL_new:
7179                case NUM_INT:
7180                case CHAR_LITERAL:
7181                case STRING_LITERAL:
7182                case NUM_FLOAT:
7183                case NUM_LONG:
7184                case NUM_DOUBLE:
7185                {
7186                        {
7187                        boolean synPredMatched317 = false;
7188                        if (((LA(1)==LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double)))) {
7189                                int _m317 = mark();
7190                                synPredMatched317 = true;
7191                                inputState.guessing++;
7192                                try {
7193                                        {
7194                                        match(LPAREN);
7195                                        builtInTypeSpec(true);
7196                                        match(RPAREN);
7197                                        unaryExpression();
7198                                        }
7199                                }
7200                                catch (RecognitionException pe) {
7201                                        synPredMatched317 = false;
7202                                }
7203                                rewind(_m317);
7204inputState.guessing--;
7205                        }
7206                        if ( synPredMatched317 ) {
7207                                lpb = LT(1);
7208                                lpb_AST = astFactory.create(lpb);
7209                                astFactory.makeASTRoot(currentAST, lpb_AST);
7210                                match(LPAREN);
7211                                if ( inputState.guessing==0 ) {
7212                                        lpb_AST.setType(TYPECAST);
7213                                }
7214                                builtInTypeSpec(true);
7215                                astFactory.addASTChild(currentAST, returnAST);
7216                                AST tmp214_AST = null;
7217                                tmp214_AST = astFactory.create(LT(1));
7218                                astFactory.addASTChild(currentAST, tmp214_AST);
7219                                match(RPAREN);
7220                                unaryExpression();
7221                                astFactory.addASTChild(currentAST, returnAST);
7222                        }
7223                        else {
7224                                boolean synPredMatched319 = false;
7225                                if (((LA(1)==LPAREN) && (LA(2)==IDENT||LA(2)==AT))) {
7226                                        int _m319 = mark();
7227                                        synPredMatched319 = true;
7228                                        inputState.guessing++;
7229                                        try {
7230                                                {
7231                                                match(LPAREN);
7232                                                typeCastParameters();
7233                                                match(RPAREN);
7234                                                unaryExpressionNotPlusMinus();
7235                                                }
7236                                        }
7237                                        catch (RecognitionException pe) {
7238                                                synPredMatched319 = false;
7239                                        }
7240                                        rewind(_m319);
7241inputState.guessing--;
7242                                }
7243                                if ( synPredMatched319 ) {
7244                                        lp = LT(1);
7245                                        lp_AST = astFactory.create(lp);
7246                                        astFactory.makeASTRoot(currentAST, lp_AST);
7247                                        match(LPAREN);
7248                                        if ( inputState.guessing==0 ) {
7249                                                lp_AST.setType(TYPECAST);
7250                                        }
7251                                        typeCastParameters();
7252                                        astFactory.addASTChild(currentAST, returnAST);
7253                                        AST tmp215_AST = null;
7254                                        tmp215_AST = astFactory.create(LT(1));
7255                                        astFactory.addASTChild(currentAST, tmp215_AST);
7256                                        match(RPAREN);
7257                                        unaryExpressionNotPlusMinus();
7258                                        astFactory.addASTChild(currentAST, returnAST);
7259                                }
7260                                else {
7261                                        boolean synPredMatched321 = false;
7262                                        if (((LA(1)==LPAREN) && (LA(2)==IDENT||LA(2)==AT))) {
7263                                                int _m321 = mark();
7264                                                synPredMatched321 = true;
7265                                                inputState.guessing++;
7266                                                try {
7267                                                        {
7268                                                        match(LPAREN);
7269                                                        typeCastParameters();
7270                                                        match(RPAREN);
7271                                                        lambdaExpression();
7272                                                        }
7273                                                }
7274                                                catch (RecognitionException pe) {
7275                                                        synPredMatched321 = false;
7276                                                }
7277                                                rewind(_m321);
7278inputState.guessing--;
7279                                        }
7280                                        if ( synPredMatched321 ) {
7281                                                lpl = LT(1);
7282                                                lpl_AST = astFactory.create(lpl);
7283                                                astFactory.makeASTRoot(currentAST, lpl_AST);
7284                                                match(LPAREN);
7285                                                if ( inputState.guessing==0 ) {
7286                                                        lpl_AST.setType(TYPECAST);
7287                                                }
7288                                                typeCastParameters();
7289                                                astFactory.addASTChild(currentAST, returnAST);
7290                                                AST tmp216_AST = null;
7291                                                tmp216_AST = astFactory.create(LT(1));
7292                                                astFactory.addASTChild(currentAST, tmp216_AST);
7293                                                match(RPAREN);
7294                                                lambdaExpression();
7295                                                astFactory.addASTChild(currentAST, returnAST);
7296                                        }
7297                                        else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_18.member(LA(2)))) {
7298                                                postfixExpression();
7299                                                astFactory.addASTChild(currentAST, returnAST);
7300                                        }
7301                                        else {
7302                                                throw new NoViableAltException(LT(1), getFilename());
7303                                        }
7304                                        }}
7305                                        }
7306                                        unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
7307                                        break;
7308                                }
7309                                default:
7310                                {
7311                                        throw new NoViableAltException(LT(1), getFilename());
7312                                }
7313                                }
7314                                returnAST = unaryExpressionNotPlusMinus_AST;
7315                        }
7316                        
7317        public final void typeCastParameters() throws RecognitionException, TokenStreamException {
7318                
7319                returnAST = null;
7320                ASTPair currentAST = new ASTPair();
7321                AST typeCastParameters_AST = null;
7322                
7323                classTypeSpec(true);
7324                astFactory.addASTChild(currentAST, returnAST);
7325                {
7326                _loop324:
7327                do {
7328                        if ((LA(1)==BAND)) {
7329                                AST tmp217_AST = null;
7330                                tmp217_AST = astFactory.create(LT(1));
7331                                astFactory.makeASTRoot(currentAST, tmp217_AST);
7332                                match(BAND);
7333                                classTypeSpec(true);
7334                                astFactory.addASTChild(currentAST, returnAST);
7335                        }
7336                        else {
7337                                break _loop324;
7338                        }
7339                        
7340                } while (true);
7341                }
7342                typeCastParameters_AST = (AST)currentAST.root;
7343                returnAST = typeCastParameters_AST;
7344        }
7345        
7346        public final void postfixExpression() throws RecognitionException, TokenStreamException {
7347                
7348                returnAST = null;
7349                ASTPair currentAST = new ASTPair();
7350                AST postfixExpression_AST = null;
7351                Token  dc = null;
7352                AST dc_AST = null;
7353                Token  lbc = null;
7354                AST lbc_AST = null;
7355                Token  lb = null;
7356                AST lb_AST = null;
7357                Token  lp = null;
7358                AST lp_AST = null;
7359                Token  in = null;
7360                AST in_AST = null;
7361                Token  de = null;
7362                AST de_AST = null;
7363                
7364                primaryExpression();
7365                astFactory.addASTChild(currentAST, returnAST);
7366                {
7367                _loop339:
7368                do {
7369                        switch ( LA(1)) {
7370                        case DOT:
7371                        {
7372                                AST tmp218_AST = null;
7373                                tmp218_AST = astFactory.create(LT(1));
7374                                astFactory.makeASTRoot(currentAST, tmp218_AST);
7375                                match(DOT);
7376                                {
7377                                if ((_tokenSet_63.member(LA(1))) && (_tokenSet_18.member(LA(2)))) {
7378                                        {
7379                                        switch ( LA(1)) {
7380                                        case LT:
7381                                        {
7382                                                typeArguments(false);
7383                                                astFactory.addASTChild(currentAST, returnAST);
7384                                                break;
7385                                        }
7386                                        case IDENT:
7387                                        case LITERAL_this:
7388                                        case LITERAL_super:
7389                                        {
7390                                                break;
7391                                        }
7392                                        default:
7393                                        {
7394                                                throw new NoViableAltException(LT(1), getFilename());
7395                                        }
7396                                        }
7397                                        }
7398                                        {
7399                                        switch ( LA(1)) {
7400                                        case IDENT:
7401                                        {
7402                                                AST tmp219_AST = null;
7403                                                tmp219_AST = astFactory.create(LT(1));
7404                                                astFactory.addASTChild(currentAST, tmp219_AST);
7405                                                match(IDENT);
7406                                                {
7407                                                boolean synPredMatched332 = false;
7408                                                if (((LA(1)==LT) && (_tokenSet_18.member(LA(2))))) {
7409                                                        int _m332 = mark();
7410                                                        synPredMatched332 = true;
7411                                                        inputState.guessing++;
7412                                                        try {
7413                                                                {
7414                                                                typeArguments(false);
7415                                                                match(DOUBLE_COLON);
7416                                                                }
7417                                                        }
7418                                                        catch (RecognitionException pe) {
7419                                                                synPredMatched332 = false;
7420                                                        }
7421                                                        rewind(_m332);
7422inputState.guessing--;
7423                                                }
7424                                                if ( synPredMatched332 ) {
7425                                                        typeArguments(false);
7426                                                        astFactory.addASTChild(currentAST, returnAST);
7427                                                }
7428                                                else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
7429                                                }
7430                                                else {
7431                                                        throw new NoViableAltException(LT(1), getFilename());
7432                                                }
7433                                                
7434                                                }
7435                                                break;
7436                                        }
7437                                        case LITERAL_this:
7438                                        {
7439                                                AST tmp220_AST = null;
7440                                                tmp220_AST = astFactory.create(LT(1));
7441                                                astFactory.addASTChild(currentAST, tmp220_AST);
7442                                                match(LITERAL_this);
7443                                                break;
7444                                        }
7445                                        case LITERAL_super:
7446                                        {
7447                                                AST tmp221_AST = null;
7448                                                tmp221_AST = astFactory.create(LT(1));
7449                                                astFactory.addASTChild(currentAST, tmp221_AST);
7450                                                match(LITERAL_super);
7451                                                break;
7452                                        }
7453                                        default:
7454                                        {
7455                                                throw new NoViableAltException(LT(1), getFilename());
7456                                        }
7457                                        }
7458                                        }
7459                                }
7460                                else if ((LA(1)==LITERAL_class) && (_tokenSet_18.member(LA(2)))) {
7461                                        AST tmp222_AST = null;
7462                                        tmp222_AST = astFactory.create(LT(1));
7463                                        astFactory.addASTChild(currentAST, tmp222_AST);
7464                                        match(LITERAL_class);
7465                                }
7466                                else if ((LA(1)==LITERAL_new) && (_tokenSet_26.member(LA(2)))) {
7467                                        newExpression();
7468                                        astFactory.addASTChild(currentAST, returnAST);
7469                                }
7470                                else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
7471                                        annotations();
7472                                        astFactory.addASTChild(currentAST, returnAST);
7473                                }
7474                                else {
7475                                        throw new NoViableAltException(LT(1), getFilename());
7476                                }
7477                                
7478                                }
7479                                break;
7480                        }
7481                        case DOUBLE_COLON:
7482                        {
7483                                dc = LT(1);
7484                                dc_AST = astFactory.create(dc);
7485                                astFactory.makeASTRoot(currentAST, dc_AST);
7486                                match(DOUBLE_COLON);
7487                                if ( inputState.guessing==0 ) {
7488                                        dc_AST.setType(METHOD_REF);
7489                                }
7490                                {
7491                                {
7492                                switch ( LA(1)) {
7493                                case LT:
7494                                {
7495                                        typeArguments(false);
7496                                        astFactory.addASTChild(currentAST, returnAST);
7497                                        break;
7498                                }
7499                                case IDENT:
7500                                case LITERAL_new:
7501                                {
7502                                        break;
7503                                }
7504                                default:
7505                                {
7506                                        throw new NoViableAltException(LT(1), getFilename());
7507                                }
7508                                }
7509                                }
7510                                {
7511                                switch ( LA(1)) {
7512                                case IDENT:
7513                                {
7514                                        AST tmp223_AST = null;
7515                                        tmp223_AST = astFactory.create(LT(1));
7516                                        astFactory.addASTChild(currentAST, tmp223_AST);
7517                                        match(IDENT);
7518                                        break;
7519                                }
7520                                case LITERAL_new:
7521                                {
7522                                        AST tmp224_AST = null;
7523                                        tmp224_AST = astFactory.create(LT(1));
7524                                        astFactory.addASTChild(currentAST, tmp224_AST);
7525                                        match(LITERAL_new);
7526                                        break;
7527                                }
7528                                default:
7529                                {
7530                                        throw new NoViableAltException(LT(1), getFilename());
7531                                }
7532                                }
7533                                }
7534                                }
7535                                break;
7536                        }
7537                        default:
7538                                if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
7539                                        {
7540                                        int _cnt337=0;
7541                                        _loop337:
7542                                        do {
7543                                                if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
7544                                                        lbc = LT(1);
7545                                                        lbc_AST = astFactory.create(lbc);
7546                                                        astFactory.makeASTRoot(currentAST, lbc_AST);
7547                                                        match(LBRACK);
7548                                                        if ( inputState.guessing==0 ) {
7549                                                                lbc_AST.setType(ARRAY_DECLARATOR);
7550                                                        }
7551                                                        AST tmp225_AST = null;
7552                                                        tmp225_AST = astFactory.create(LT(1));
7553                                                        astFactory.addASTChild(currentAST, tmp225_AST);
7554                                                        match(RBRACK);
7555                                                }
7556                                                else {
7557                                                        if ( _cnt337>=1 ) { break _loop337; } else {throw new NoViableAltException(LT(1), getFilename());}
7558                                                }
7559                                                
7560                                                _cnt337++;
7561                                        } while (true);
7562                                        }
7563                                        {
7564                                        if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) {
7565                                                AST tmp226_AST = null;
7566                                                tmp226_AST = astFactory.create(LT(1));
7567                                                astFactory.makeASTRoot(currentAST, tmp226_AST);
7568                                                match(DOT);
7569                                                AST tmp227_AST = null;
7570                                                tmp227_AST = astFactory.create(LT(1));
7571                                                astFactory.addASTChild(currentAST, tmp227_AST);
7572                                                match(LITERAL_class);
7573                                        }
7574                                        else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
7575                                        }
7576                                        else {
7577                                                throw new NoViableAltException(LT(1), getFilename());
7578                                        }
7579                                        
7580                                        }
7581                                }
7582                                else if ((LA(1)==LBRACK) && (_tokenSet_16.member(LA(2)))) {
7583                                        lb = LT(1);
7584                                        lb_AST = astFactory.create(lb);
7585                                        astFactory.makeASTRoot(currentAST, lb_AST);
7586                                        match(LBRACK);
7587                                        if ( inputState.guessing==0 ) {
7588                                                lb_AST.setType(INDEX_OP);
7589                                        }
7590                                        expression();
7591                                        astFactory.addASTChild(currentAST, returnAST);
7592                                        AST tmp228_AST = null;
7593                                        tmp228_AST = astFactory.create(LT(1));
7594                                        astFactory.addASTChild(currentAST, tmp228_AST);
7595                                        match(RBRACK);
7596                                }
7597                                else if ((LA(1)==LPAREN) && (_tokenSet_64.member(LA(2)))) {
7598                                        lp = LT(1);
7599                                        lp_AST = astFactory.create(lp);
7600                                        astFactory.makeASTRoot(currentAST, lp_AST);
7601                                        match(LPAREN);
7602                                        if ( inputState.guessing==0 ) {
7603                                                lp_AST.setType(METHOD_CALL);
7604                                        }
7605                                        argList();
7606                                        astFactory.addASTChild(currentAST, returnAST);
7607                                        AST tmp229_AST = null;
7608                                        tmp229_AST = astFactory.create(LT(1));
7609                                        astFactory.addASTChild(currentAST, tmp229_AST);
7610                                        match(RPAREN);
7611                                }
7612                        else {
7613                                break _loop339;
7614                        }
7615                        }
7616                } while (true);
7617                }
7618                {
7619                if ((LA(1)==INC) && (_tokenSet_65.member(LA(2)))) {
7620                        in = LT(1);
7621                        in_AST = astFactory.create(in);
7622                        astFactory.makeASTRoot(currentAST, in_AST);
7623                        match(INC);
7624                        if ( inputState.guessing==0 ) {
7625                                in_AST.setType(POST_INC);
7626                        }
7627                }
7628                else if ((LA(1)==DEC) && (_tokenSet_65.member(LA(2)))) {
7629                        de = LT(1);
7630                        de_AST = astFactory.create(de);
7631                        astFactory.makeASTRoot(currentAST, de_AST);
7632                        match(DEC);
7633                        if ( inputState.guessing==0 ) {
7634                                de_AST.setType(POST_DEC);
7635                        }
7636                }
7637                else if ((_tokenSet_65.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
7638                }
7639                else {
7640                        throw new NoViableAltException(LT(1), getFilename());
7641                }
7642                
7643                }
7644                postfixExpression_AST = (AST)currentAST.root;
7645                returnAST = postfixExpression_AST;
7646        }
7647        
7648/** object instantiation.
7649 *  Trees are built as illustrated by the following input/tree pairs:
7650 *
7651 *  new T()
7652 *
7653 *  new
7654 *   |
7655 *   T --  ELIST
7656 *           |
7657 *          arg1 -- arg2 -- .. -- argn
7658 *
7659 *  new int[]
7660 *
7661 *  new
7662 *   |
7663 *  int -- ARRAY_DECLARATOR
7664 *
7665 *  new int[] {1,2}
7666 *
7667 *  new
7668 *   |
7669 *  int -- ARRAY_DECLARATOR -- ARRAY_INIT
7670 *                                  |
7671 *                                EXPR -- EXPR
7672 *                                  |      |
7673 *                                  1      2
7674 *
7675 *  new int[3]
7676 *  new
7677 *   |
7678 *  int -- ARRAY_DECLARATOR
7679 *                |
7680 *              EXPR
7681 *                |
7682 *                3
7683 *
7684 *  new int[1][2]
7685 *
7686 *  new
7687 *   |
7688 *  int -- ARRAY_DECLARATOR
7689 *               |
7690 *         ARRAY_DECLARATOR -- EXPR
7691 *               |              |
7692 *             EXPR             1
7693 *               |
7694 *               2
7695 *
7696 *
7697 * @throws RecognitionException if recognition problem occurs.
7698 * @throws TokenStreamException if problem occurs while generating a stream of tokens.
7699 */
7700        public final void newExpression() throws RecognitionException, TokenStreamException {
7701                
7702                returnAST = null;
7703                ASTPair currentAST = new ASTPair();
7704                AST newExpression_AST = null;
7705                
7706                AST tmp230_AST = null;
7707                tmp230_AST = astFactory.create(LT(1));
7708                astFactory.makeASTRoot(currentAST, tmp230_AST);
7709                match(LITERAL_new);
7710                {
7711                switch ( LA(1)) {
7712                case LT:
7713                {
7714                        typeArguments(false);
7715                        astFactory.addASTChild(currentAST, returnAST);
7716                        break;
7717                }
7718                case LITERAL_void:
7719                case LITERAL_boolean:
7720                case LITERAL_byte:
7721                case LITERAL_char:
7722                case LITERAL_short:
7723                case LITERAL_int:
7724                case LITERAL_float:
7725                case LITERAL_long:
7726                case LITERAL_double:
7727                case IDENT:
7728                case AT:
7729                {
7730                        break;
7731                }
7732                default:
7733                {
7734                        throw new NoViableAltException(LT(1), getFilename());
7735                }
7736                }
7737                }
7738                type();
7739                astFactory.addASTChild(currentAST, returnAST);
7740                {
7741                switch ( LA(1)) {
7742                case LPAREN:
7743                {
7744                        AST tmp231_AST = null;
7745                        tmp231_AST = astFactory.create(LT(1));
7746                        astFactory.addASTChild(currentAST, tmp231_AST);
7747                        match(LPAREN);
7748                        argList();
7749                        astFactory.addASTChild(currentAST, returnAST);
7750                        AST tmp232_AST = null;
7751                        tmp232_AST = astFactory.create(LT(1));
7752                        astFactory.addASTChild(currentAST, tmp232_AST);
7753                        match(RPAREN);
7754                        {
7755                        if ((LA(1)==LCURLY) && (_tokenSet_29.member(LA(2)))) {
7756                                classBlock();
7757                                astFactory.addASTChild(currentAST, returnAST);
7758                        }
7759                        else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
7760                        }
7761                        else {
7762                                throw new NoViableAltException(LT(1), getFilename());
7763                        }
7764                        
7765                        }
7766                        break;
7767                }
7768                case LBRACK:
7769                {
7770                        newArrayDeclarator();
7771                        astFactory.addASTChild(currentAST, returnAST);
7772                        {
7773                        if ((LA(1)==LCURLY) && (_tokenSet_66.member(LA(2)))) {
7774                                arrayInitializer();
7775                                astFactory.addASTChild(currentAST, returnAST);
7776                        }
7777                        else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
7778                        }
7779                        else {
7780                                throw new NoViableAltException(LT(1), getFilename());
7781                        }
7782                        
7783                        }
7784                        break;
7785                }
7786                default:
7787                {
7788                        throw new NoViableAltException(LT(1), getFilename());
7789                }
7790                }
7791                }
7792                newExpression_AST = (AST)currentAST.root;
7793                returnAST = newExpression_AST;
7794        }
7795        
7796        public final void constant() throws RecognitionException, TokenStreamException {
7797                
7798                returnAST = null;
7799                ASTPair currentAST = new ASTPair();
7800                AST constant_AST = null;
7801                
7802                switch ( LA(1)) {
7803                case NUM_INT:
7804                {
7805                        AST tmp233_AST = null;
7806                        tmp233_AST = astFactory.create(LT(1));
7807                        astFactory.addASTChild(currentAST, tmp233_AST);
7808                        match(NUM_INT);
7809                        constant_AST = (AST)currentAST.root;
7810                        break;
7811                }
7812                case NUM_LONG:
7813                {
7814                        AST tmp234_AST = null;
7815                        tmp234_AST = astFactory.create(LT(1));
7816                        astFactory.addASTChild(currentAST, tmp234_AST);
7817                        match(NUM_LONG);
7818                        constant_AST = (AST)currentAST.root;
7819                        break;
7820                }
7821                case NUM_FLOAT:
7822                {
7823                        AST tmp235_AST = null;
7824                        tmp235_AST = astFactory.create(LT(1));
7825                        astFactory.addASTChild(currentAST, tmp235_AST);
7826                        match(NUM_FLOAT);
7827                        constant_AST = (AST)currentAST.root;
7828                        break;
7829                }
7830                case NUM_DOUBLE:
7831                {
7832                        AST tmp236_AST = null;
7833                        tmp236_AST = astFactory.create(LT(1));
7834                        astFactory.addASTChild(currentAST, tmp236_AST);
7835                        match(NUM_DOUBLE);
7836                        constant_AST = (AST)currentAST.root;
7837                        break;
7838                }
7839                case CHAR_LITERAL:
7840                {
7841                        AST tmp237_AST = null;
7842                        tmp237_AST = astFactory.create(LT(1));
7843                        astFactory.addASTChild(currentAST, tmp237_AST);
7844                        match(CHAR_LITERAL);
7845                        constant_AST = (AST)currentAST.root;
7846                        break;
7847                }
7848                case STRING_LITERAL:
7849                {
7850                        AST tmp238_AST = null;
7851                        tmp238_AST = astFactory.create(LT(1));
7852                        astFactory.addASTChild(currentAST, tmp238_AST);
7853                        match(STRING_LITERAL);
7854                        constant_AST = (AST)currentAST.root;
7855                        break;
7856                }
7857                default:
7858                {
7859                        throw new NoViableAltException(LT(1), getFilename());
7860                }
7861                }
7862                returnAST = constant_AST;
7863        }
7864        
7865        public final void newArrayDeclarator() throws RecognitionException, TokenStreamException {
7866                
7867                returnAST = null;
7868                ASTPair currentAST = new ASTPair();
7869                AST newArrayDeclarator_AST = null;
7870                Token  lb = null;
7871                AST lb_AST = null;
7872                
7873                {
7874                int _cnt361=0;
7875                _loop361:
7876                do {
7877                        if ((LA(1)==LBRACK) && (_tokenSet_67.member(LA(2)))) {
7878                                lb = LT(1);
7879                                lb_AST = astFactory.create(lb);
7880                                astFactory.makeASTRoot(currentAST, lb_AST);
7881                                match(LBRACK);
7882                                if ( inputState.guessing==0 ) {
7883                                        lb_AST.setType(ARRAY_DECLARATOR);
7884                                }
7885                                {
7886                                switch ( LA(1)) {
7887                                case LITERAL_void:
7888                                case LITERAL_boolean:
7889                                case LITERAL_byte:
7890                                case LITERAL_char:
7891                                case LITERAL_short:
7892                                case LITERAL_int:
7893                                case LITERAL_float:
7894                                case LITERAL_long:
7895                                case LITERAL_double:
7896                                case IDENT:
7897                                case LPAREN:
7898                                case LITERAL_this:
7899                                case LITERAL_super:
7900                                case PLUS:
7901                                case MINUS:
7902                                case INC:
7903                                case DEC:
7904                                case BNOT:
7905                                case LNOT:
7906                                case LITERAL_true:
7907                                case LITERAL_false:
7908                                case LITERAL_null:
7909                                case LITERAL_new:
7910                                case NUM_INT:
7911                                case CHAR_LITERAL:
7912                                case STRING_LITERAL:
7913                                case NUM_FLOAT:
7914                                case NUM_LONG:
7915                                case NUM_DOUBLE:
7916                                {
7917                                        expression();
7918                                        astFactory.addASTChild(currentAST, returnAST);
7919                                        break;
7920                                }
7921                                case RBRACK:
7922                                {
7923                                        break;
7924                                }
7925                                default:
7926                                {
7927                                        throw new NoViableAltException(LT(1), getFilename());
7928                                }
7929                                }
7930                                }
7931                                AST tmp239_AST = null;
7932                                tmp239_AST = astFactory.create(LT(1));
7933                                astFactory.addASTChild(currentAST, tmp239_AST);
7934                                match(RBRACK);
7935                        }
7936                        else {
7937                                if ( _cnt361>=1 ) { break _loop361; } else {throw new NoViableAltException(LT(1), getFilename());}
7938                        }
7939                        
7940                        _cnt361++;
7941                } while (true);
7942                }
7943                newArrayDeclarator_AST = (AST)currentAST.root;
7944                returnAST = newArrayDeclarator_AST;
7945        }
7946        
7947        public final void lambdaParameters() throws RecognitionException, TokenStreamException {
7948                
7949                returnAST = null;
7950                ASTPair currentAST = new ASTPair();
7951                AST lambdaParameters_AST = null;
7952                
7953                if ((LA(1)==IDENT)) {
7954                        AST tmp240_AST = null;
7955                        tmp240_AST = astFactory.create(LT(1));
7956                        astFactory.addASTChild(currentAST, tmp240_AST);
7957                        match(IDENT);
7958                        lambdaParameters_AST = (AST)currentAST.root;
7959                }
7960                else if ((LA(1)==LPAREN) && (_tokenSet_68.member(LA(2)))) {
7961                        AST tmp241_AST = null;
7962                        tmp241_AST = astFactory.create(LT(1));
7963                        astFactory.addASTChild(currentAST, tmp241_AST);
7964                        match(LPAREN);
7965                        {
7966                        if ((_tokenSet_68.member(LA(1))) && (_tokenSet_69.member(LA(2)))) {
7967                                parameterDeclarationList();
7968                                astFactory.addASTChild(currentAST, returnAST);
7969                        }
7970                        else if ((LA(1)==RPAREN) && (LA(2)==LAMBDA)) {
7971                        }
7972                        else {
7973                                throw new NoViableAltException(LT(1), getFilename());
7974                        }
7975                        
7976                        }
7977                        AST tmp242_AST = null;
7978                        tmp242_AST = astFactory.create(LT(1));
7979                        astFactory.addASTChild(currentAST, tmp242_AST);
7980                        match(RPAREN);
7981                        lambdaParameters_AST = (AST)currentAST.root;
7982                }
7983                else if ((LA(1)==LPAREN) && (LA(2)==IDENT)) {
7984                        AST tmp243_AST = null;
7985                        tmp243_AST = astFactory.create(LT(1));
7986                        astFactory.addASTChild(currentAST, tmp243_AST);
7987                        match(LPAREN);
7988                        inferredParameterList();
7989                        astFactory.addASTChild(currentAST, returnAST);
7990                        AST tmp244_AST = null;
7991                        tmp244_AST = astFactory.create(LT(1));
7992                        astFactory.addASTChild(currentAST, tmp244_AST);
7993                        match(RPAREN);
7994                        lambdaParameters_AST = (AST)currentAST.root;
7995                }
7996                else {
7997                        throw new NoViableAltException(LT(1), getFilename());
7998                }
7999                
8000                returnAST = lambdaParameters_AST;
8001        }
8002        
8003        public final void lambdaBody() throws RecognitionException, TokenStreamException {
8004                
8005                returnAST = null;
8006                ASTPair currentAST = new ASTPair();
8007                AST lambdaBody_AST = null;
8008                
8009                {
8010                if ((_tokenSet_16.member(LA(1))) && (_tokenSet_70.member(LA(2)))) {
8011                        expression();
8012                        astFactory.addASTChild(currentAST, returnAST);
8013                }
8014                else if ((_tokenSet_36.member(LA(1))) && (_tokenSet_70.member(LA(2)))) {
8015                        statement();
8016                        astFactory.addASTChild(currentAST, returnAST);
8017                }
8018                else {
8019                        throw new NoViableAltException(LT(1), getFilename());
8020                }
8021                
8022                }
8023                lambdaBody_AST = (AST)currentAST.root;
8024                returnAST = lambdaBody_AST;
8025        }
8026        
8027        public final void inferredParameterList() throws RecognitionException, TokenStreamException {
8028                
8029                returnAST = null;
8030                ASTPair currentAST = new ASTPair();
8031                AST inferredParameterList_AST = null;
8032                
8033                AST tmp245_AST = null;
8034                tmp245_AST = astFactory.create(LT(1));
8035                astFactory.addASTChild(currentAST, tmp245_AST);
8036                match(IDENT);
8037                {
8038                _loop370:
8039                do {
8040                        if ((LA(1)==COMMA)) {
8041                                AST tmp246_AST = null;
8042                                tmp246_AST = astFactory.create(LT(1));
8043                                astFactory.addASTChild(currentAST, tmp246_AST);
8044                                match(COMMA);
8045                                AST tmp247_AST = null;
8046                                tmp247_AST = astFactory.create(LT(1));
8047                                astFactory.addASTChild(currentAST, tmp247_AST);
8048                                match(IDENT);
8049                        }
8050                        else {
8051                                break _loop370;
8052                        }
8053                        
8054                } while (true);
8055                }
8056                inferredParameterList_AST = (AST)currentAST.root;
8057                returnAST = inferredParameterList_AST;
8058        }
8059        
8060        
8061        public static final String[] _tokenNames = {
8062                "<0>",
8063                "EOF",
8064                "<2>",
8065                "NULL_TREE_LOOKAHEAD",
8066                "BLOCK",
8067                "MODIFIERS",
8068                "OBJBLOCK",
8069                "SLIST",
8070                "CTOR_DEF",
8071                "METHOD_DEF",
8072                "VARIABLE_DEF",
8073                "INSTANCE_INIT",
8074                "STATIC_INIT",
8075                "TYPE",
8076                "CLASS_DEF",
8077                "INTERFACE_DEF",
8078                "PACKAGE_DEF",
8079                "ARRAY_DECLARATOR",
8080                "EXTENDS_CLAUSE",
8081                "IMPLEMENTS_CLAUSE",
8082                "PARAMETERS",
8083                "PARAMETER_DEF",
8084                "LABELED_STAT",
8085                "TYPECAST",
8086                "INDEX_OP",
8087                "POST_INC",
8088                "POST_DEC",
8089                "METHOD_CALL",
8090                "EXPR",
8091                "ARRAY_INIT",
8092                "IMPORT",
8093                "UNARY_MINUS",
8094                "UNARY_PLUS",
8095                "CASE_GROUP",
8096                "ELIST",
8097                "FOR_INIT",
8098                "FOR_CONDITION",
8099                "FOR_ITERATOR",
8100                "EMPTY_STAT",
8101                "\"final\"",
8102                "\"abstract\"",
8103                "\"strictfp\"",
8104                "SUPER_CTOR_CALL",
8105                "CTOR_CALL",
8106                "\"package\"",
8107                "SEMI",
8108                "\"import\"",
8109                "LBRACK",
8110                "RBRACK",
8111                "\"void\"",
8112                "\"boolean\"",
8113                "\"byte\"",
8114                "\"char\"",
8115                "\"short\"",
8116                "\"int\"",
8117                "\"float\"",
8118                "\"long\"",
8119                "\"double\"",
8120                "IDENT",
8121                "DOT",
8122                "STAR",
8123                "\"private\"",
8124                "\"public\"",
8125                "\"protected\"",
8126                "\"static\"",
8127                "\"transient\"",
8128                "\"native\"",
8129                "\"synchronized\"",
8130                "\"volatile\"",
8131                "\"class\"",
8132                "\"extends\"",
8133                "\"interface\"",
8134                "LCURLY",
8135                "RCURLY",
8136                "COMMA",
8137                "\"implements\"",
8138                "LPAREN",
8139                "RPAREN",
8140                "\"this\"",
8141                "\"super\"",
8142                "ASSIGN",
8143                "\"throws\"",
8144                "COLON",
8145                "\"if\"",
8146                "\"while\"",
8147                "\"do\"",
8148                "\"break\"",
8149                "\"continue\"",
8150                "\"return\"",
8151                "\"switch\"",
8152                "\"throw\"",
8153                "\"for\"",
8154                "\"else\"",
8155                "\"case\"",
8156                "\"default\"",
8157                "\"try\"",
8158                "\"catch\"",
8159                "\"finally\"",
8160                "PLUS_ASSIGN",
8161                "MINUS_ASSIGN",
8162                "STAR_ASSIGN",
8163                "DIV_ASSIGN",
8164                "MOD_ASSIGN",
8165                "SR_ASSIGN",
8166                "BSR_ASSIGN",
8167                "SL_ASSIGN",
8168                "BAND_ASSIGN",
8169                "BXOR_ASSIGN",
8170                "BOR_ASSIGN",
8171                "QUESTION",
8172                "LOR",
8173                "LAND",
8174                "BOR",
8175                "BXOR",
8176                "BAND",
8177                "NOT_EQUAL",
8178                "EQUAL",
8179                "LT",
8180                "GT",
8181                "LE",
8182                "GE",
8183                "\"instanceof\"",
8184                "SL",
8185                "SR",
8186                "BSR",
8187                "PLUS",
8188                "MINUS",
8189                "DIV",
8190                "MOD",
8191                "INC",
8192                "DEC",
8193                "BNOT",
8194                "LNOT",
8195                "\"true\"",
8196                "\"false\"",
8197                "\"null\"",
8198                "\"new\"",
8199                "NUM_INT",
8200                "CHAR_LITERAL",
8201                "STRING_LITERAL",
8202                "NUM_FLOAT",
8203                "NUM_LONG",
8204                "NUM_DOUBLE",
8205                "WS",
8206                "SINGLE_LINE_COMMENT",
8207                "BLOCK_COMMENT_BEGIN",
8208                "ESC",
8209                "HEX_DIGIT",
8210                "VOCAB",
8211                "EXPONENT",
8212                "FLOAT_SUFFIX",
8213                "ASSERT",
8214                "STATIC_IMPORT",
8215                "ENUM",
8216                "ENUM_DEF",
8217                "ENUM_CONSTANT_DEF",
8218                "FOR_EACH_CLAUSE",
8219                "ANNOTATION_DEF",
8220                "ANNOTATIONS",
8221                "ANNOTATION",
8222                "ANNOTATION_MEMBER_VALUE_PAIR",
8223                "ANNOTATION_FIELD_DEF",
8224                "ANNOTATION_ARRAY_INIT",
8225                "TYPE_ARGUMENTS",
8226                "TYPE_ARGUMENT",
8227                "TYPE_PARAMETERS",
8228                "TYPE_PARAMETER",
8229                "WILDCARD_TYPE",
8230                "TYPE_UPPER_BOUNDS",
8231                "TYPE_LOWER_BOUNDS",
8232                "AT",
8233                "ELLIPSIS",
8234                "GENERIC_START",
8235                "GENERIC_END",
8236                "TYPE_EXTENSION_AND",
8237                "DO_WHILE",
8238                "RESOURCE_SPECIFICATION",
8239                "RESOURCES",
8240                "RESOURCE",
8241                "DOUBLE_COLON",
8242                "METHOD_REF",
8243                "LAMBDA",
8244                "BLOCK_COMMENT_END",
8245                "COMMENT_CONTENT",
8246                "SINGLE_LINE_COMMENT_CONTENT",
8247                "BLOCK_COMMENT_CONTENT",
8248                "STD_ESC",
8249                "BINARY_DIGIT",
8250                "ID_START",
8251                "ID_PART",
8252                "INT_LITERAL",
8253                "LONG_LITERAL",
8254                "FLOAT_LITERAL",
8255                "DOUBLE_LITERAL",
8256                "HEX_FLOAT_LITERAL",
8257                "HEX_DOUBLE_LITERAL",
8258                "SIGNED_INTEGER",
8259                "BINARY_EXPONENT"
8260        };
8261        
8262        protected void buildTokenTypeASTClassMap() {
8263                tokenTypeToASTClassMap=null;
8264        };
8265        
8266        private static final long[] mk_tokenSet_0() {
8267                long[] data = { -2305733607806730238L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
8268                return data;
8269        }
8270        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
8271        private static final long[] mk_tokenSet_1() {
8272                long[] data = { -2017503231655018494L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
8273                return data;
8274        }
8275        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
8276        private static final long[] mk_tokenSet_2() {
8277                long[] data = { -2305803976550907904L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
8278                return data;
8279        }
8280        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
8281        private static final long[] mk_tokenSet_3() {
8282                long[] data = { -2305803976550907902L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
8283                return data;
8284        }
8285        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
8286        private static final long[] mk_tokenSet_4() {
8287                long[] data = { -2305839160922996736L, 1073741855L, 0L, 0L};
8288                return data;
8289        }
8290        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
8291        private static final long[] mk_tokenSet_5() {
8292                long[] data = { -101704825569280L, -12885032961L, 2264993995194367L, 0L, 0L, 0L};
8293                return data;
8294        }
8295        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
8296        private static final long[] mk_tokenSet_6() {
8297                long[] data = { -84112639524862L, -131073L, 11272193249935359L, 0L, 0L, 0L};
8298                return data;
8299        }
8300        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
8301        private static final long[] mk_tokenSet_7() {
8302                long[] data = { 575897802350002176L, 35184372088832L, 4398046511104L, 0L, 0L, 0L};
8303                return data;
8304        }
8305        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
8306        private static final long[] mk_tokenSet_8() {
8307                long[] data = { 0L, 1747396655419752448L, 0L, 0L};
8308                return data;
8309        }
8310        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
8311        private static final long[] mk_tokenSet_9() {
8312                long[] data = { 575897802350002176L, 0L, 4398046511104L, 0L, 0L, 0L};
8313                return data;
8314        }
8315        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
8316        private static final long[] mk_tokenSet_10() {
8317                long[] data = { 575897802350002176L, 6917529027641143552L, 4398046543870L, 0L, 0L, 0L};
8318                return data;
8319        }
8320        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
8321        private static final long[] mk_tokenSet_11() {
8322                long[] data = { -84112639524864L, -12885035073L, 2256197902172159L, 0L, 0L, 0L};
8323                return data;
8324        }
8325        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
8326        private static final long[] mk_tokenSet_12() {
8327                long[] data = { 575897802350002176L, 6917529027641135360L, 4398046543870L, 0L, 0L, 0L};
8328                return data;
8329        }
8330        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
8331        private static final long[] mk_tokenSet_13() {
8332                long[] data = { 2305420796748627968L, -35184372026880L, 2256197860229119L, 0L, 0L, 0L};
8333                return data;
8334        }
8335        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
8336        private static final long[] mk_tokenSet_14() {
8337                long[] data = { 575897802350002176L, 6917529027641135104L, 4398046543870L, 0L, 0L, 0L};
8338                return data;
8339        }
8340        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
8341        private static final long[] mk_tokenSet_15() {
8342                long[] data = { 575898352105816064L, 8192L, 9011597301252096L, 0L, 0L, 0L};
8343                return data;
8344        }
8345        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
8346        private static final long[] mk_tokenSet_16() {
8347                long[] data = { 575897802350002176L, 6917529027641135104L, 32766L, 0L, 0L, 0L};
8348                return data;
8349        }
8350        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
8351        private static final long[] mk_tokenSet_17() {
8352                long[] data = { 2305420796748627968L, -17179488256L, 2256197860229119L, 0L, 0L, 0L};
8353                return data;
8354        }
8355        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
8356        private static final long[] mk_tokenSet_18() {
8357                long[] data = { -101704825569280L, -12885035073L, 2256197902172159L, 0L, 0L, 0L};
8358                return data;
8359        }
8360        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
8361        private static final long[] mk_tokenSet_19() {
8362                long[] data = { 575897802350002176L, 1747396655419755840L, 4398046511104L, 0L, 0L, 0L};
8363                return data;
8364        }
8365        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
8366        private static final long[] mk_tokenSet_20() {
8367                long[] data = { -1153304684409126912L, 9007200328489983L, 4398080065536L, 0L, 0L, 0L};
8368                return data;
8369        }
8370        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
8371        private static final long[] mk_tokenSet_21() {
8372                long[] data = { 0L, 160L, 4398080065536L, 0L, 0L, 0L};
8373                return data;
8374        }
8375        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
8376        private static final long[] mk_tokenSet_22() {
8377                long[] data = { 864831865943490560L, 9007199254740992L, 0L, 0L};
8378                return data;
8379        }
8380        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
8381        private static final long[] mk_tokenSet_23() {
8382                long[] data = { 175921860444160L, 66560L, 0L, 0L};
8383                return data;
8384        }
8385        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
8386        private static final long[] mk_tokenSet_24() {
8387                long[] data = { -1729941358572994560L, 9007200328483007L, 4398080065536L, 0L, 0L, 0L};
8388                return data;
8389        }
8390        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
8391        private static final long[] mk_tokenSet_25() {
8392                long[] data = { -1153339868781215744L, 9007200328487103L, 4398080065536L, 0L, 0L, 0L};
8393                return data;
8394        }
8395        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
8396        private static final long[] mk_tokenSet_26() {
8397                long[] data = { 575897802350002176L, 9007199254740992L, 4398046511104L, 0L, 0L, 0L};
8398                return data;
8399        }
8400        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
8401        private static final long[] mk_tokenSet_27() {
8402                long[] data = { 864831865943490560L, 9007199254745088L, 0L, 0L};
8403                return data;
8404        }
8405        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
8406        private static final long[] mk_tokenSet_28() {
8407                long[] data = { -1729765436712550400L, 9007200328550335L, 4398080065536L, 0L, 0L, 0L};
8408                return data;
8409        }
8410        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
8411        private static final long[] mk_tokenSet_29() {
8412                long[] data = { -1729906174200905728L, 9007200328483775L, 4398080065536L, 0L, 0L, 0L};
8413                return data;
8414        }
8415        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
8416        private static final long[] mk_tokenSet_30() {
8417                long[] data = { -101704825569278L, -12885035073L, 2256197902172159L, 0L, 0L, 0L};
8418                return data;
8419        }
8420        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
8421        private static final long[] mk_tokenSet_31() {
8422                long[] data = { 575898352105816064L, 0L, 4398046511104L, 0L, 0L, 0L};
8423                return data;
8424        }
8425        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
8426        private static final long[] mk_tokenSet_32() {
8427                long[] data = { 1152499292141780992L, 9007199254750208L, 4398046511104L, 0L, 0L, 0L};
8428                return data;
8429        }
8430        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
8431        private static final long[] mk_tokenSet_33() {
8432                long[] data = { 1152499292141780992L, 9007199254740992L, 13194139533312L, 0L, 0L, 0L};
8433                return data;
8434        }
8435        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
8436        private static final long[] mk_tokenSet_34() {
8437                long[] data = { 864726312827224064L, 1280L, 0L, 0L};
8438                return data;
8439        }
8440        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
8441        private static final long[] mk_tokenSet_35() {
8442                long[] data = { 576495936675512320L, 1280L, 0L, 0L};
8443                return data;
8444        }
8445        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
8446        private static final long[] mk_tokenSet_36() {
8447                long[] data = { -1729906174200905728L, 6917529031130272063L, 4398054932478L, 0L, 0L, 0L};
8448                return data;
8449        }
8450        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
8451        private static final long[] mk_tokenSet_37() {
8452                long[] data = { 575897802350002176L, 9007199254794240L, 32736L, 0L, 0L, 0L};
8453                return data;
8454        }
8455        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
8456        private static final long[] mk_tokenSet_38() {
8457                long[] data = { 1152499292141780992L, 8673968066687717376L, 4398046543870L, 0L, 0L, 0L};
8458                return data;
8459        }
8460        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
8461        private static final long[] mk_tokenSet_39() {
8462                long[] data = { -1729906174200905728L, 6917529031130272575L, 4398054932478L, 0L, 0L, 0L};
8463                return data;
8464        }
8465        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
8466        private static final long[] mk_tokenSet_40() {
8467                long[] data = { -383179802279936L, -13690342465L, 11263397156913151L, 0L, 0L, 0L};
8468                return data;
8469        }
8470        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
8471        private static final long[] mk_tokenSet_41() {
8472                long[] data = { 0L, 9007199254790144L, 0L, 0L};
8473                return data;
8474        }
8475        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
8476        private static final long[] mk_tokenSet_42() {
8477                long[] data = { 575897802350002176L, 1747431839791894528L, 4398046511104L, 0L, 0L, 0L};
8478                return data;
8479        }
8480        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
8481        private static final long[] mk_tokenSet_43() {
8482                long[] data = { 575897802350002176L, 53248L, 32736L, 0L, 0L, 0L};
8483                return data;
8484        }
8485        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
8486        private static final long[] mk_tokenSet_44() {
8487                long[] data = { 1152499292141780992L, 6926536226895876096L, 4398046543870L, 0L, 0L, 0L};
8488                return data;
8489        }
8490        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
8491        private static final long[] mk_tokenSet_45() {
8492                long[] data = { -84112639524862L, -133185L, 11263397156913151L, 0L, 0L, 0L};
8493                return data;
8494        }
8495        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
8496        private static final long[] mk_tokenSet_46() {
8497                long[] data = { 2305420796748627968L, -17179742208L, 2256197860229119L, 0L, 0L, 0L};
8498                return data;
8499        }
8500        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
8501        private static final long[] mk_tokenSet_47() {
8502                long[] data = { 575897802350002176L, 6917529027641135360L, 32766L, 0L, 0L, 0L};
8503                return data;
8504        }
8505        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
8506        private static final long[] mk_tokenSet_48() {
8507                long[] data = { 140737488355328L, 9216L, 0L, 0L};
8508                return data;
8509        }
8510        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
8511        private static final long[] mk_tokenSet_49() {
8512                long[] data = { -1729906174200905728L, 6917529031935849279L, 4398054932478L, 0L, 0L, 0L};
8513                return data;
8514        }
8515        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
8516        private static final long[] mk_tokenSet_50() {
8517                long[] data = { -101704825569280L, -133185L, 11263397156913151L, 0L, 0L, 0L};
8518                return data;
8519        }
8520        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
8521        private static final long[] mk_tokenSet_51() {
8522                long[] data = { -1729941358572994560L, 1073741855L, 4398046511104L, 0L, 0L, 0L};
8523                return data;
8524        }
8525        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
8526        private static final long[] mk_tokenSet_52() {
8527                long[] data = { -1153339868781215744L, 9007200328482847L, 4398046511104L, 0L, 0L, 0L};
8528                return data;
8529        }
8530        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
8531        private static final long[] mk_tokenSet_53() {
8532                long[] data = { -383179802279936L, -12885036225L, 11263397123358719L, 0L, 0L, 0L};
8533                return data;
8534        }
8535        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
8536        private static final long[] mk_tokenSet_54() {
8537                long[] data = { -2305839160922996736L, 1073741887L, 4398046511104L, 0L, 0L, 0L};
8538                return data;
8539        }
8540        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
8541        private static final long[] mk_tokenSet_55() {
8542                long[] data = { -2017608784771284992L, 1073741887L, 4398046511104L, 0L, 0L, 0L};
8543                return data;
8544        }
8545        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
8546        private static final long[] mk_tokenSet_56() {
8547                long[] data = { -1729906174200905728L, 6917529028714876959L, 4398046543870L, 0L, 0L, 0L};
8548                return data;
8549        }
8550        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
8551        private static final long[] mk_tokenSet_57() {
8552                long[] data = { -383179802279936L, -16105999329L, 11263397114970111L, 0L, 0L, 0L};
8553                return data;
8554        }
8555        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
8556        private static final long[] mk_tokenSet_58() {
8557                long[] data = { 575897802350002176L, 6917529027641397248L, 32766L, 0L, 0L, 0L};
8558                return data;
8559        }
8560        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
8561        private static final long[] mk_tokenSet_59() {
8562                long[] data = { -383179802279936L, -13153471681L, 11263397123358719L, 0L, 0L, 0L};
8563                return data;
8564        }
8565        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
8566        private static final long[] mk_tokenSet_60() {
8567                long[] data = { 0L, 1610613248L, 0L, 0L};
8568                return data;
8569        }
8570        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
8571        private static final long[] mk_tokenSet_61() {
8572                long[] data = { 2305456530876530688L, -17179741184L, 11263397114970111L, 0L, 0L, 0L};
8573                return data;
8574        }
8575        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
8576        private static final long[] mk_tokenSet_62() {
8577                long[] data = { 1152921504606846976L, -9223372036854775808L, 1L, 0L, 0L, 0L};
8578                return data;
8579        }
8580        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
8581        private static final long[] mk_tokenSet_63() {
8582                long[] data = { 288230376151711744L, 9007199254790144L, 0L, 0L};
8583                return data;
8584        }
8585        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
8586        private static final long[] mk_tokenSet_64() {
8587                long[] data = { 575897802350002176L, 6917529027641143296L, 32766L, 0L, 0L, 0L};
8588                return data;
8589        }
8590        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
8591        private static final long[] mk_tokenSet_65() {
8592                long[] data = { -576703194617348096L, -12885035073L, 4398088486911L, 0L, 0L, 0L};
8593                return data;
8594        }
8595        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
8596        private static final long[] mk_tokenSet_66() {
8597                long[] data = { 575897802350002176L, 6917529027641136896L, 32766L, 0L, 0L, 0L};
8598                return data;
8599        }
8600        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
8601        private static final long[] mk_tokenSet_67() {
8602                long[] data = { 576179277326712832L, 6917529027641135104L, 32766L, 0L, 0L, 0L};
8603                return data;
8604        }
8605        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
8606        private static final long[] mk_tokenSet_68() {
8607                long[] data = { 575898352105816064L, 8192L, 4398046511104L, 0L, 0L, 0L};
8608                return data;
8609        }
8610        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
8611        private static final long[] mk_tokenSet_69() {
8612                long[] data = { 1152499292141780992L, 9007199254750208L, 9020393394274304L, 0L, 0L, 0L};
8613                return data;
8614        }
8615        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
8616        private static final long[] mk_tokenSet_70() {
8617                long[] data = { -101704825569280L, -12885035073L, 11263397156913151L, 0L, 0L, 0L};
8618                return data;
8619        }
8620        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
8621        
8622        }