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