View Javadoc
Minimize
Table

Bug Overview

linebug prioritybugbug descriptionexisting sinceauthor
491mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
1708mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
1892mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
1958mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
2429mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
2860mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
2983mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
3131mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
3260mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
3564mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
3867mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
3977mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
4038mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
4493mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
5086mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
5146mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
5273mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
5332mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
5457mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
5613mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
5815mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
6014mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
6121mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
6576mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
6649mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
7027mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
7156mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
7716mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
7953mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
8011mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
8552mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
8971mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
9296mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
9601mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
9714mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
9808mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
9898mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
10190mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
10353mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
10468mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
10897mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
10952mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
11070mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
11138mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
11329mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
12021mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
12150mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
12423mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
12499mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
12646mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
13056mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
13162mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
13701mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
223mediumTODODer Code ist an dieser Stelle eventuell unfertig oder fehlerhaft. Bitte überprüfen!18.06.2012-10:31UNKNOWN
316mediumTODODer Code ist an dieser Stelle eventuell unfertig oder fehlerhaft. Bitte überprüfen!18.06.2012-10:31UNKNOWN
339mediumDE_MIGHT_IGNOREDiese Methode ignoriert möglicherweise eine Exception, diese sollten aber behandelt oder angezeigt werden. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
412mediumSystemPrintlnBitte keine System.(out|err).print-Ausgaben verwenden, stattdessen Logger-Klassen nutzen. Details zum Fehler...18.06.2012-10:31UNKNOWN
491mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
689lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
796mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
818mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
867mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
960mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
992lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
1423mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
2133mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
2336mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
2368mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
2417mediumRCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPEDieser Wert wird auf null überprüft, obwohl bei der vorangegangenen Wertzuweisung bereits eine NullPointerException auftreten müsste falls der Wert null ist. Die Überprüfung ist entweder redundant oder die Zuweisung ist fehlerhaft. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
2547mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
2708mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
2983mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3094mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3299mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3443mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3564mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3593mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
4023mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
4420lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
4493mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
4834mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
5202lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
5457mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
5758mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
5815mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
6254mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
6389mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
6403lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
6649mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
6663lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
6752lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
7156mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
7312mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
7567mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
7968mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
7991mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
8011mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
8285mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
8366mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
8397mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
8612mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
8884mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
8971mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
8997lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
9333mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
9356mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
9575mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
9605lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
10150mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
10236mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
10288mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
10497lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
11329mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
11415lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
11672mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
11798lowCodeDuplicateAn dieser Stelle wurde ein Codeduplikat festgestellt, dabei besteht immer die Möglichkeit Fehler mit zu kopieren. Bitte Code überprüfen!  Details zum Fehler...18.06.2012-10:31UNKNOWN
12583mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
12646mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
13162mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
13348mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
13529mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
13787mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
13916mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN

1   // $ANTLR 2.7.7 (20060906): "groovy.g" -> "GroovyRecognizer.java"$
2   
3   package org.codehaus.groovy.antlr.parser;
4   import org.codehaus.groovy.antlr.*;
5   import java.util.*;
6   import java.io.InputStream;
7   import java.io.Reader;
8   import antlr.InputBuffer;
9   import antlr.LexerSharedInputState;
10  import antlr.CommonToken;
11  import org.codehaus.groovy.GroovyBugError;
12  import antlr.TokenStreamRecognitionException;
13  
14  import antlr.TokenBuffer;
15  import antlr.TokenStreamException;
16  import antlr.TokenStreamIOException;
17  import antlr.ANTLRException;
18  import antlr.LLkParser;
19  import antlr.Token;
20  import antlr.TokenStream;
21  import antlr.RecognitionException;
22  import antlr.NoViableAltException;
23  import antlr.MismatchedTokenException;
24  import antlr.SemanticException;
25  import antlr.ParserSharedInputState;
26  import antlr.collections.impl.BitSet;
27  import antlr.collections.AST;
28  import java.util.Hashtable;
29  import antlr.ASTFactory;
30  import antlr.ASTPair;
31  import antlr.collections.impl.ASTArray;
32  
33  /** JSR-241 Groovy Recognizer.
34   *
35   * Run 'java Main [-showtree] directory-full-of-groovy-files'
36   *
37   * [The -showtree option pops up a Swing frame that shows
38   *  the AST constructed from the parser.]
39   *
40   * Contributing authors:
41   *              John Mitchell           johnm@non.net
42   *              Terence Parr            parrt@magelang.com
43   *              John Lilley             jlilley@empathy.com
44   *              Scott Stanchfield       thetick@magelang.com
45   *              Markus Mohnen           mohnen@informatik.rwth-aachen.de
46   *              Peter Williams          pete.williams@sun.com
47   *              Allan Jacobs            Allan.Jacobs@eng.sun.com
48   *              Steve Messick           messick@redhills.com
49   *              James Strachan          jstrachan@protique.com
50   *              John Pybus              john@pybus.org
51   *              John Rose               rose00@mac.com
52   *              Jeremy Rayner           groovy@ross-rayner.com
53   *              Alex Popescu            the.mindstorm@gmail.com
54   *              Martin Kempf            mkempf@hsr.ch
55   *              Reto Kleeb              rkleeb@hsr.ch
56   *
57   * Version 1.00 December 9, 1997 -- initial release
58   * Version 1.01 December 10, 1997
59   *              fixed bug in octal def (0..7 not 0..8)
60   * Version 1.10 August 1998 (parrt)
61   *              added tree construction
62   *              fixed definition of WS,comments for mac,pc,unix newlines
63   *              added unary plus
64   * Version 1.11 (Nov 20, 1998)
65   *              Added "shutup" option to turn off last ambig warning.
66   *              Fixed inner class def to allow named class defs as statements
67   *              synchronized requires compound not simple statement
68   *              add [] after builtInType DOT class in primaryExpression
69   *              "const" is reserved but not valid..removed from modifiers
70   * Version 1.12 (Feb 2, 1999)
71   *              Changed LITERAL_xxx to xxx in tree grammar.
72   *              Updated java.g to use tokens {...} now for 2.6.0 (new feature).
73   *
74   * Version 1.13 (Apr 23, 1999)
75   *              Didn't have (stat)? for else clause in tree parser.
76   *              Didn't gen ASTs for interface extends.  Updated tree parser too.
77   *              Updated to 2.6.0.
78   * Version 1.14 (Jun 20, 1999)
79   *              Allowed final/abstract on local classes.
80   *              Removed local interfaces from methods
81   *              Put instanceof precedence where it belongs...in relationalExpr
82   *                      It also had expr not type as arg; fixed it.
83   *              Missing ! on SEMI in classBlock
84   *              fixed: (expr) + "string" was parsed incorrectly (+ as unary plus).
85   *              fixed: didn't like Object[].class in parser or tree parser
86   * Version 1.15 (Jun 26, 1999)
87   *              Screwed up rule with instanceof in it. :(  Fixed.
88   *              Tree parser didn't like (expr).something; fixed.
89   *              Allowed multiple inheritance in tree grammar. oops.
90   * Version 1.16 (August 22, 1999)
91   *              Extending an interface built a wacky tree: had extra EXTENDS.
92   *              Tree grammar didn't allow multiple superinterfaces.
93   *              Tree grammar didn't allow empty var initializer: {}
94   * Version 1.17 (October 12, 1999)
95   *              ESC lexer rule allowed 399 max not 377 max.
96   *              java.tree.g didn't handle the expression of synchronized
97   *              statements.
98   * Version 1.18 (August 12, 2001)
99   *              Terence updated to Java 2 Version 1.3 by
100  *              observing/combining work of Allan Jacobs and Steve
101  *              Messick.  Handles 1.3 src.  Summary:
102  *              o  primary didn't include boolean.class kind of thing
103  *              o  constructor calls parsed explicitly now:
104  *                 see explicitConstructorInvocation
105  *              o  add strictfp modifier
106  *              o  missing objBlock after new expression in tree grammar
107  *              o  merged local class definition alternatives, moved after declaration
108  *              o  fixed problem with ClassName.super.field
109  *              o  reordered some alternatives to make things more efficient
110  *              o  long and double constants were not differentiated from int/float
111  *              o  whitespace rule was inefficient: matched only one char
112  *              o  add an examples directory with some nasty 1.3 cases
113  *              o  made Main.java use buffered IO and a Reader for Unicode support
114  *              o  supports UNICODE?
115  *                 Using Unicode charVocabulary makes code file big, but only
116  *                 in the bitsets at the end. I need to make ANTLR generate
117  *                 unicode bitsets more efficiently.
118  * Version 1.19 (April 25, 2002)
119  *              Terence added in nice fixes by John Pybus concerning floating
120  *              constants and problems with super() calls.  John did a nice
121  *              reorg of the primary/postfix expression stuff to read better
122  *              and makes f.g.super() parse properly (it was METHOD_CALL not
123  *              a SUPER_CTOR_CALL).  Also:
124  *
125  *              o  "finally" clause was a root...made it a child of "try"
126  *              o  Added stuff for asserts too for Java 1.4, but *commented out*
127  *                 as it is not backward compatible.
128  *
129  * Version 1.20 (October 27, 2002)
130  *
131  *        Terence ended up reorging John Pybus' stuff to
132  *        remove some nondeterminisms and some syntactic predicates.
133  *        Note that the grammar is stricter now; e.g., this(...) must
134  *      be the first statement.
135  *
136  *        Trinary ?: operator wasn't working as array name:
137  *                (isBig ? bigDigits : digits)[i];
138  *
139  *        Checked parser/tree parser on source for
140  *                Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4,
141  *              and the 110k-line jGuru server source.
142  *
143  * Version 1.21 (October 17, 2003)
144  *  Fixed lots of problems including:
145  *  Ray Waldin: add typeDefinition to interfaceBlock in java.tree.g
146  *  He found a problem/fix with floating point that start with 0
147  *  Ray also fixed problem that (int.class) was not recognized.
148  *  Thorsten van Ellen noticed that \n are allowed incorrectly in strings.
149  *  TJP fixed CHAR_LITERAL analogously.
150  *
151  * Version 1.21.2 (March, 2003)
152  *        Changes by Matt Quail to support generics (as per JDK1.5/JSR14)
153  *        Notes:
154  *        o We only allow the "extends" keyword and not the "implements"
155  *              keyword, since that's what JSR14 seems to imply.
156  *        o Thanks to Monty Zukowski for his help on the antlr-interest
157  *              mail list.
158  *        o Thanks to Alan Eliasen for testing the grammar over his
159  *              Fink source base
160  *
161  * Version 1.22 (July, 2004)
162  *        Changes by Michael Studman to support Java 1.5 language extensions
163  *        Notes:
164  *        o Added support for annotations types
165  *        o Finished off Matt Quail's generics enhancements to support bound type arguments
166  *        o Added support for new for statement syntax
167  *        o Added support for static import syntax
168  *        o Added support for enum types
169  *        o Tested against JDK 1.5 source base and source base of jdigraph project
170  *        o Thanks to Matt Quail for doing the hard part by doing most of the generics work
171  *
172  * Version 1.22.1 (July 28, 2004)
173  *        Bug/omission fixes for Java 1.5 language support
174  *        o Fixed tree structure bug with classOrInterface - thanks to Pieter Vangorpto for
175  *              spotting this
176  *        o Fixed bug where incorrect handling of SR and BSR tokens would cause type
177  *              parameters to be recognised as type arguments.
178  *        o Enabled type parameters on constructors, annotations on enum constants
179  *              and package definitions
180  *        o Fixed problems when parsing if ((char.class.equals(c))) {} - solution by Matt Quail at Cenqua
181  *
182  * Version 1.22.2 (July 28, 2004)
183  *        Slight refactoring of Java 1.5 language support
184  *        o Refactored for/"foreach" productions so that original literal "for" literal
185  *          is still used but the for sub-clauses vary by token type
186  *        o Fixed bug where type parameter was not included in generic constructor's branch of AST
187  *
188  * Version 1.22.3 (August 26, 2004)
189  *        Bug fixes as identified by Michael Stahl; clean up of tabs/spaces
190  *        and other refactorings
191  *        o Fixed typeParameters omission in identPrimary and newStatement
192  *        o Replaced GT reconcilliation code with simple semantic predicate
193  *        o Adapted enum/assert keyword checking support from Michael Stahl's java15 grammar
194  *        o Refactored typeDefinition production and field productions to reduce duplication
195  *
196  * Version 1.22.4 (October 21, 2004)
197  *    Small bux fixes
198  *    o Added typeArguments to explicitConstructorInvocation, e.g. new <String>MyParameterised()
199  *    o Added typeArguments to postfixExpression productions for anonymous inner class super
200  *      constructor invocation, e.g. new Outer().<String>super()
201  *    o Fixed bug in array declarations identified by Geoff Roy
202  *
203  * Version 1.22.4.g.1
204  *    o I have taken java.g for Java1.5 from Michael Studman (1.22.4)
205  *      and have applied the groovy.diff from java.g (1.22) by John Rose
206  *      back onto the new root (1.22.4) - Jeremy Rayner (Jan 2005)
207  *    o for a map of the task see...
208  *      http://groovy.javanicus.com/java-g.png
209  *
210  * Version 1.22.4.g.2
211  *    o mkempf, rkleeb, Dec 2007
212  *    o fixed various rules so that they call the correct Create Method
213  *      to make sure that the line information are correct
214  *
215  * This grammar is in the PUBLIC DOMAIN
216  */
217 public class GroovyRecognizer extends antlr.LLkParser       implements GroovyTokenTypes
218  {
219 
220         /** This factory is the correct way to wire together a Groovy parser and lexer. */
221     public static GroovyRecognizer make(GroovyLexer lexer) {
222         GroovyRecognizer parser = new GroovyRecognizer(lexer.plumb());
223 bug overview next bug           // TODO: set up a common error-handling control block, to avoid excessive tangle between these guys 
224         parser.lexer = lexer;
225         lexer.parser = parser;
226         parser.getASTFactory().setASTNodeClass(GroovySourceAST.class);
227         parser.warningList = new ArrayList();
228         return parser;
229     }
230     // Create a scanner that reads from the input stream passed to us...
231     public static GroovyRecognizer make(InputStream in) { return make(new GroovyLexer(in)); }
232     public static GroovyRecognizer make(Reader in) { return make(new GroovyLexer(in)); }
233     public static GroovyRecognizer make(InputBuffer in) { return make(new GroovyLexer(in)); }
234     public static GroovyRecognizer make(LexerSharedInputState in) { return make(new GroovyLexer(in)); }
235 
236     private static GroovySourceAST dummyVariableToforceClassLoaderToFindASTClass = new GroovySourceAST();
237 
238     List warningList;
239     public List getWarningList() { return warningList; }
240 
241     GroovyLexer lexer;
242     public GroovyLexer getLexer() { return lexer; }
243     public void setFilename(String f) { super.setFilename(f); lexer.setFilename(f); }
244     private SourceBuffer sourceBuffer;
245     public void setSourceBuffer(SourceBuffer sourceBuffer) {
246         this.sourceBuffer = sourceBuffer;
247     }
248 
249     /** Create an AST node with the token type and text passed in, but
250      *  with the same background information as another supplied Token (e.g.&nbsp;line numbers).
251      * To be used in place of antlr tree construction syntax,
252      * i.e. #[TOKEN,"text"]  becomes  create(TOKEN,"text",anotherToken)
253      *
254      * todo - change antlr.ASTFactory to do this instead...
255      */
256     public AST create(int type, String txt, AST first) {
257         AST t = astFactory.create(type,txt);
258         if ( t != null && first != null) {
259             // first copy details from first token
260             t.initialize(first);
261             // then ensure that type and txt are specific to this new node
262             t.initialize(type,txt);
263         }
264         return t;
265     }
266 
267     private AST attachLast(AST t, Object last) {
268         if ((t instanceof GroovySourceAST) && (last instanceof SourceInfo)) {
269             SourceInfo lastInfo = (SourceInfo) last;
270             GroovySourceAST node = (GroovySourceAST)t;
271             node.setColumnLast(lastInfo.getColumn());
272             node.setLineLast(lastInfo.getLine());
273             // This is a good point to call node.setSnippet(),
274             // but it bulks up the AST too much for production code.
275         }
276         return t;
277     }
278 
279     public AST create(int type, String txt, Token first, Token last) {
280         return attachLast(create(type, txt, astFactory.create(first)), last);
281     }
282 
283     public AST create(int type, String txt, AST first, Token last) {
284         return attachLast(create(type, txt, first), last);
285     }
286 
287     public AST create(int type, String txt, AST first, AST last) {
288         return attachLast(create(type, txt, first), last);
289     }
290 
291     /**
292     *   Clones the token
293     */
294     public Token cloneToken(Token t) {
295         CommonToken clone = new CommonToken(t.getType(),t.getText());
296         clone.setLine(t.getLine());
297         clone.setColumn(t.getColumn());
298         return clone;
299     }
300 
301 
302     // stuff to adjust ANTLR's tracing machinery
303     public static boolean tracing = false;  // only effective if antlr.Tool is run with -traceParser
304     public void traceIn(String rname) throws TokenStreamException {
305         if (!GroovyRecognizer.tracing)  return;
306         super.traceIn(rname);
307     }
308     public void traceOut(String rname) throws TokenStreamException {
309         if (!GroovyRecognizer.tracing)  return;
310         if (returnAST != null)  rname += returnAST.toStringList();
311         super.traceOut(rname);
312     }
313 
314     // Error handling.  This is a funnel through which parser errors go, when the parser can suggest a solution.
315     public void requireFailed(String problem, String solution) throws SemanticException {
316 previous bug bug overview next bug           // TODO: Needs more work. 
317         Token lt = null;
318         int lineNum = Token.badToken.getLine(), colNum = Token.badToken.getColumn();
319         try {
320             lt = LT(1);
321             if(lt != null) {
322                 lineNum = lt.getLine();
323                 colNum = lt.getColumn();
324             }
325         }
326         catch (TokenStreamException ee) {
327             if(ee instanceof TokenStreamRecognitionException) {
328                 lineNum = ((TokenStreamRecognitionException) ee).recog.getLine();
329                 colNum = ((TokenStreamRecognitionException) ee).recog.getColumn();
330             }
331         }
332         throw new SemanticException(problem + ";\n   solution: " + solution,
333                                     getFilename(), lineNum, colNum);
334     }
335 
336     public void addWarning(String warning, String solution) {
337         Token lt = null;
338         try { lt = LT(1); }
339 previous bug bug overview next bug           catch (TokenStreamException ee) { }  HEALTH4J >>  :  DE_MIGHT_IGNORE 
340         if (lt == null)  lt = Token.badToken;
341 
342         Map row = new HashMap();
343         row.put("warning",  warning);
344         row.put("solution", solution);
345         row.put("filename", getFilename());
346         row.put("line",     Integer.valueOf(lt.getLine()));
347         row.put("column",   Integer.valueOf(lt.getColumn()));
348         // System.out.println(row);
349         warningList.add(row);
350     }
351 
352     // Convenience method for checking of expected error syndromes.
353     private void require(boolean z, String problem, String solution) throws SemanticException {
354         if (!z)  requireFailed(problem, solution);
355     }
356 
357     private boolean matchGenericTypeBrackets(boolean z, String problem, String solution) throws SemanticException {
358         if (!z)  matchGenericTypeBracketsFailed(problem, solution);
359         return z;
360     }
361 
362     public void matchGenericTypeBracketsFailed(String problem, String solution) throws SemanticException {
363         Token lt = null;
364         int lineNum = Token.badToken.getLine(), colNum = Token.badToken.getColumn();
365 
366         try {
367             lt = LT(1);
368             if(lt != null) {
369                 lineNum = lt.getLine();
370                 colNum = lt.getColumn();
371             }
372         }
373         catch (TokenStreamException ee) {
374             if(ee instanceof TokenStreamRecognitionException) {
375                 lineNum = ((TokenStreamRecognitionException) ee).recog.getLine();
376                 colNum = ((TokenStreamRecognitionException) ee).recog.getColumn();
377             }
378         }
379 
380         throw new SemanticException(problem + ";\n   solution: " + solution,
381                                     getFilename(), lineNum, colNum);
382    }
383 
384     // Query a name token to see if it begins with a capital letter.
385     // This is used to tell the difference (w/o symbol table access) between {String x} and {println x}.
386     private boolean isUpperCase(Token x) {
387         if (x == null || x.getType() != IDENT)  return false;  // cannot happen?
388         String xtext = x.getText();
389         return (xtext.length() > 0 && Character.isUpperCase(xtext.charAt(0)));
390     }
391 
392     private AST currentClass = null;  // current enclosing class (for constructor recognition)
393     // Query a name token to see if it is identical with the current class name.
394     // This is used to distinguish constructors from other methods.
395     private boolean isConstructorIdent(Token x) {
396         if (currentClass == null)  return false;
397         if (currentClass.getType() != IDENT)  return false;  // cannot happen?
398         String cname = currentClass.getText();
399 
400         if (x == null || x.getType() != IDENT)  return false;  // cannot happen?
401         return cname.equals(x.getText());
402     }
403     
404     private void dumpTree(AST ast, String offset) {
405     	dump(ast, offset);
406         for (AST node = ast.getFirstChild(); node != null; node = node.getNextSibling()) {
407             dumpTree(node, offset+"\t");
408         }
409     }
410 
411     private void dump(AST node, String offset) {
412 previous bug bug overview next bug           System.out.println(offset+"Type: " + getTokenName(node) + " text: " + node.getText());  HEALTH4J >>  :  SystemPrintln 
413     }
414     
415     private String getTokenName(AST node) {
416         if (node == null) return "null";
417         return getTokenName(node.getType());
418     }
419 
420     // Scratch variable for last 'sep' token.
421     // Written by the 'sep' rule, read only by immediate callers of 'sep'.
422     // (Not entirely clean, but better than a million xx=sep occurrences.)
423     private int sepToken = EOF;
424 
425     // Scratch variable for last argument list; tells whether there was a label.
426     // Written by 'argList' rule, read only by immediate callers of 'argList'.
427     private boolean argListHasLabels = false;
428 
429     // Scratch variable, holds most recently completed pathExpression.
430     // Read only by immediate callers of 'pathExpression' and 'expression'.
431     private AST lastPathExpression = null;
432 
433     // Inherited attribute pushed into most expression rules.
434     // If not zero, it means that the left context of the expression
435     // being parsed is a statement boundary or an initializer sign '='.
436     // Only such expressions are allowed to reach across newlines
437     // to pull in an LCURLY and appended block.
438     private final int LC_STMT = 1, LC_INIT = 2;
439 
440     /**
441      * Counts the number of LT seen in the typeArguments production.
442      * It is used in semantic predicates to ensure we have seen
443      * enough closing '>' characters; which actually may have been
444      * either GT, SR or BSR tokens.
445      */
446     private int ltCounter = 0;
447 
448     /* This symbol is used to work around a known ANTLR limitation.
449      * In a loop with syntactic predicate, ANTLR needs help knowing
450      * that the loop exit is a second alternative.
451      * Example usage:  ( (LCURLY)=> block | {ANTLR_LOOP_EXIT}? )*
452      * Probably should be an ANTLR RFE.
453      */
454     ////// Original comment in Java grammar:
455     // Unfortunately a syntactic predicate can only select one of
456     // multiple alternatives on the same level, not break out of
457     // an enclosing loop, which is why this ugly hack (a fake
458     // empty alternative with always-false semantic predicate)
459     // is necessary.
460     private static final boolean ANTLR_LOOP_EXIT = false;
461 
462 protected GroovyRecognizer(TokenBuffer tokenBuf, int k) {
463   super(tokenBuf,k);
464   tokenNames = _tokenNames;
465   buildTokenTypeASTClassMap();
466   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
467 }
468 
469 public GroovyRecognizer(TokenBuffer tokenBuf) {
470   this(tokenBuf,2);
471 }
472 
473 protected GroovyRecognizer(TokenStream lexer, int k) {
474   super(lexer,k);
475   tokenNames = _tokenNames;
476   buildTokenTypeASTClassMap();
477   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
478 }
479 
480 public GroovyRecognizer(TokenStream lexer) {
481   this(lexer,2);
482 }
483 
484 public GroovyRecognizer(ParserSharedInputState state) {
485   super(state,2);
486   tokenNames = _tokenNames;
487   buildTokenTypeASTClassMap();
488   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
489 }
490 
491 previous bug bug overview next bug   	public final void compilationUnit() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc  ExcessiveMethodLength 
492 		
493 		returnAST = null;
494 		ASTPair currentAST = new ASTPair();
495 		AST compilationUnit_AST = null;
496 		
497 		{
498 		switch ( LA(1)) {
499 		case SH_COMMENT:
500 		{
501 			match(SH_COMMENT);
502 			break;
503 		}
504 		case EOF:
505 		case FINAL:
506 		case ABSTRACT:
507 		case STRICTFP:
508 		case LITERAL_package:
509 		case LITERAL_import:
510 		case LITERAL_static:
511 		case LITERAL_def:
512 		case LBRACK:
513 		case IDENT:
514 		case STRING_LITERAL:
515 		case LPAREN:
516 		case LITERAL_class:
517 		case LITERAL_interface:
518 		case LITERAL_enum:
519 		case AT:
520 		case LITERAL_super:
521 		case LITERAL_void:
522 		case LITERAL_boolean:
523 		case LITERAL_byte:
524 		case LITERAL_char:
525 		case LITERAL_short:
526 		case LITERAL_int:
527 		case LITERAL_float:
528 		case LITERAL_long:
529 		case LITERAL_double:
530 		case LITERAL_private:
531 		case LITERAL_public:
532 		case LITERAL_protected:
533 		case LITERAL_transient:
534 		case LITERAL_native:
535 		case LITERAL_threadsafe:
536 		case LITERAL_synchronized:
537 		case LITERAL_volatile:
538 		case LCURLY:
539 		case SEMI:
540 		case LITERAL_this:
541 		case LITERAL_if:
542 		case LITERAL_while:
543 		case LITERAL_switch:
544 		case LITERAL_for:
545 		case LITERAL_return:
546 		case LITERAL_break:
547 		case LITERAL_continue:
548 		case LITERAL_throw:
549 		case LITERAL_assert:
550 		case PLUS:
551 		case MINUS:
552 		case LITERAL_try:
553 		case LITERAL_false:
554 		case LITERAL_new:
555 		case LITERAL_null:
556 		case LITERAL_true:
557 		case INC:
558 		case DEC:
559 		case BNOT:
560 		case LNOT:
561 		case STRING_CTOR_START:
562 		case NUM_INT:
563 		case NUM_FLOAT:
564 		case NUM_LONG:
565 		case NUM_DOUBLE:
566 		case NUM_BIG_INT:
567 		case NUM_BIG_DECIMAL:
568 		case NLS:
569 		{
570 			break;
571 		}
572 		default:
573 		{
574 			throw new NoViableAltException(LT(1), getFilename());
575 		}
576 		}
577 		}
578 		nls();
579 		{
580 		boolean synPredMatched5 = false;
581 		if (((LA(1)==LITERAL_package||LA(1)==AT) && (LA(2)==IDENT||LA(2)==LITERAL_interface))) {
582 			int _m5 = mark();
583 			synPredMatched5 = true;
584 			inputState.guessing++;
585 			try {
586 				{
587 				annotationsOpt();
588 				match(LITERAL_package);
589 				}
590 			}
591 			catch (RecognitionException pe) {
592 				synPredMatched5 = false;
593 			}
594 			rewind(_m5);
595 inputState.guessing--;
596 		}
597 		if ( synPredMatched5 ) {
598 			packageDefinition();
599 			astFactory.addASTChild(currentAST, returnAST);
600 		}
601 		else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
602 			{
603 			switch ( LA(1)) {
604 			case FINAL:
605 			case ABSTRACT:
606 			case STRICTFP:
607 			case LITERAL_import:
608 			case LITERAL_static:
609 			case LITERAL_def:
610 			case LBRACK:
611 			case IDENT:
612 			case STRING_LITERAL:
613 			case LPAREN:
614 			case LITERAL_class:
615 			case LITERAL_interface:
616 			case LITERAL_enum:
617 			case AT:
618 			case LITERAL_super:
619 			case LITERAL_void:
620 			case LITERAL_boolean:
621 			case LITERAL_byte:
622 			case LITERAL_char:
623 			case LITERAL_short:
624 			case LITERAL_int:
625 			case LITERAL_float:
626 			case LITERAL_long:
627 			case LITERAL_double:
628 			case LITERAL_private:
629 			case LITERAL_public:
630 			case LITERAL_protected:
631 			case LITERAL_transient:
632 			case LITERAL_native:
633 			case LITERAL_threadsafe:
634 			case LITERAL_synchronized:
635 			case LITERAL_volatile:
636 			case LCURLY:
637 			case LITERAL_this:
638 			case LITERAL_if:
639 			case LITERAL_while:
640 			case LITERAL_switch:
641 			case LITERAL_for:
642 			case LITERAL_return:
643 			case LITERAL_break:
644 			case LITERAL_continue:
645 			case LITERAL_throw:
646 			case LITERAL_assert:
647 			case PLUS:
648 			case MINUS:
649 			case LITERAL_try:
650 			case LITERAL_false:
651 			case LITERAL_new:
652 			case LITERAL_null:
653 			case LITERAL_true:
654 			case INC:
655 			case DEC:
656 			case BNOT:
657 			case LNOT:
658 			case STRING_CTOR_START:
659 			case NUM_INT:
660 			case NUM_FLOAT:
661 			case NUM_LONG:
662 			case NUM_DOUBLE:
663 			case NUM_BIG_INT:
664 			case NUM_BIG_DECIMAL:
665 			{
666 				statement(EOF);
667 				astFactory.addASTChild(currentAST, returnAST);
668 				break;
669 			}
670 			case EOF:
671 			case SEMI:
672 			case NLS:
673 			{
674 				break;
675 			}
676 			default:
677 			{
678 				throw new NoViableAltException(LT(1), getFilename());
679 			}
680 			}
681 			}
682 		}
683 		else {
684 			throw new NoViableAltException(LT(1), getFilename());
685 		}
686 		
687 		}
688 		{
689 previous bug bug overview next bug   		_loop9: 
690 		do {
691 			if ((LA(1)==SEMI||LA(1)==NLS)) {
692 				sep();
693 				{
694 				switch ( LA(1)) {
695 				case FINAL:
696 				case ABSTRACT:
697 				case STRICTFP:
698 				case LITERAL_import:
699 				case LITERAL_static:
700 				case LITERAL_def:
701 				case LBRACK:
702 				case IDENT:
703 				case STRING_LITERAL:
704 				case LPAREN:
705 				case LITERAL_class:
706 				case LITERAL_interface:
707 				case LITERAL_enum:
708 				case AT:
709 				case LITERAL_super:
710 				case LITERAL_void:
711 				case LITERAL_boolean:
712 				case LITERAL_byte:
713 				case LITERAL_char:
714 				case LITERAL_short:
715 				case LITERAL_int:
716 				case LITERAL_float:
717 				case LITERAL_long:
718 				case LITERAL_double:
719 				case LITERAL_private:
720 				case LITERAL_public:
721 				case LITERAL_protected:
722 				case LITERAL_transient:
723 				case LITERAL_native:
724 				case LITERAL_threadsafe:
725 				case LITERAL_synchronized:
726 				case LITERAL_volatile:
727 				case LCURLY:
728 				case LITERAL_this:
729 				case LITERAL_if:
730 				case LITERAL_while:
731 				case LITERAL_switch:
732 				case LITERAL_for:
733 				case LITERAL_return:
734 				case LITERAL_break:
735 				case LITERAL_continue:
736 				case LITERAL_throw:
737 				case LITERAL_assert:
738 				case PLUS:
739 				case MINUS:
740 				case LITERAL_try:
741 				case LITERAL_false:
742 				case LITERAL_new:
743 				case LITERAL_null:
744 				case LITERAL_true:
745 				case INC:
746 				case DEC:
747 				case BNOT:
748 				case LNOT:
749 				case STRING_CTOR_START:
750 				case NUM_INT:
751 				case NUM_FLOAT:
752 				case NUM_LONG:
753 				case NUM_DOUBLE:
754 				case NUM_BIG_INT:
755 				case NUM_BIG_DECIMAL:
756 				{
757 					statement(sepToken);
758 					astFactory.addASTChild(currentAST, returnAST);
759 					break;
760 				}
761 				case EOF:
762 				case SEMI:
763 				case NLS:
764 				{
765 					break;
766 				}
767 				default:
768 				{
769 					throw new NoViableAltException(LT(1), getFilename());
770 				}
771 				}
772 				}
773 			}
774 			else {
775 				break _loop9;
776 			}
777 			
778 		} while (true);
779 		}
780 		match(Token.EOF_TYPE);
781 		compilationUnit_AST = (AST)currentAST.root;
782 		returnAST = compilationUnit_AST;
783 	}
784 	
785 /** Zero or more insignificant newlines, all gobbled up and thrown away. */
786 	public final void nls() throws RecognitionException, TokenStreamException {
787 		
788 		returnAST = null;
789 		ASTPair currentAST = new ASTPair();
790 		AST nls_AST = null;
791 		
792 		{
793 		if ((LA(1)==NLS) && (_tokenSet_2.member(LA(2)))) {
794 			match(NLS);
795 		}
796 previous bug bug overview next bug   		else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
797 		}
798 		else {
799 			throw new NoViableAltException(LT(1), getFilename());
800 		}
801 		
802 		}
803 		returnAST = nls_AST;
804 	}
805 	
806 	public final void annotationsOpt() throws RecognitionException, TokenStreamException {
807 		
808 		returnAST = null;
809 		ASTPair currentAST = new ASTPair();
810 		AST annotationsOpt_AST = null;
811 		Token first = LT(1);
812 		
813 		{
814 		if ((_tokenSet_4.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
815 			annotationsInternal();
816 			astFactory.addASTChild(currentAST, returnAST);
817 		}
818 previous bug bug overview next bug   		else if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
819 		}
820 		else {
821 			throw new NoViableAltException(LT(1), getFilename());
822 		}
823 		
824 		}
825 		if ( inputState.guessing==0 ) {
826 			annotationsOpt_AST = (AST)currentAST.root;
827 			annotationsOpt_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(ANNOTATIONS,"ANNOTATIONS",first,LT(1))).add(annotationsOpt_AST));
828 			currentAST.root = annotationsOpt_AST;
829 			currentAST.child = annotationsOpt_AST!=null &&annotationsOpt_AST.getFirstChild()!=null ?
830 				annotationsOpt_AST.getFirstChild() : annotationsOpt_AST;
831 			currentAST.advanceChildToEnd();
832 		}
833 		annotationsOpt_AST = (AST)currentAST.root;
834 		returnAST = annotationsOpt_AST;
835 	}
836 	
837 	public final void packageDefinition() throws RecognitionException, TokenStreamException {
838 		
839 		returnAST = null;
840 		ASTPair currentAST = new ASTPair();
841 		AST packageDefinition_AST = null;
842 		AST an_AST = null;
843 		AST id_AST = null;
844 		Token first = LT(1);
845 		
846 		annotationsOpt();
847 		an_AST = (AST)returnAST;
848 		match(LITERAL_package);
849 		identifier();
850 		id_AST = (AST)returnAST;
851 		if ( inputState.guessing==0 ) {
852 			packageDefinition_AST = (AST)currentAST.root;
853 			packageDefinition_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(PACKAGE_DEF,"package",first,LT(1))).add(an_AST).add(id_AST));
854 			currentAST.root = packageDefinition_AST;
855 			currentAST.child = packageDefinition_AST!=null &&packageDefinition_AST.getFirstChild()!=null ?
856 				packageDefinition_AST.getFirstChild() : packageDefinition_AST;
857 			currentAST.advanceChildToEnd();
858 		}
859 		packageDefinition_AST = (AST)currentAST.root;
860 		returnAST = packageDefinition_AST;
861 	}
862 	
863 /** A statement is an element of a block.
864  *  Typical statements are declarations (which are scoped to the block)
865  *  and expressions.
866  */
867 previous bug bug overview next bug   	public final void statement(  HEALTH4J >>  :  ExcessiveMethodLength 
868 		int prevToken
869 	) throws RecognitionException, TokenStreamException {
870 		
871 		returnAST = null;
872 		ASTPair currentAST = new ASTPair();
873 		AST statement_AST = null;
874 		AST pfx_AST = null;
875 		AST es_AST = null;
876 		AST ale_AST = null;
877 		AST ifCbs_AST = null;
878 		AST elseCbs_AST = null;
879 		AST while_sce_AST = null;
880 		Token  s = null;
881 		AST s_AST = null;
882 		AST while_cbs_AST = null;
883 		AST m_AST = null;
884 		AST switchSce_AST = null;
885 		AST cg_AST = null;
886 		AST synch_sce_AST = null;
887 		AST synch_cs_AST = null;
888 		boolean sce=false; Token first = LT(1); AST casesGroup_AST = null;
889 		
890 		switch ( LA(1)) {
891 		case LITERAL_if:
892 		{
893 			match(LITERAL_if);
894 			match(LPAREN);
895 			assignmentLessExpression();
896 			ale_AST = (AST)returnAST;
897 			match(RPAREN);
898 			nlsWarn();
899 			compatibleBodyStatement();
900 			ifCbs_AST = (AST)returnAST;
901 			{
902 			boolean synPredMatched301 = false;
903 			if (((_tokenSet_8.member(LA(1))) && (_tokenSet_9.member(LA(2))))) {
904 				int _m301 = mark();
905 				synPredMatched301 = true;
906 				inputState.guessing++;
907 				try {
908 					{
909 					{
910 					switch ( LA(1)) {
911 					case SEMI:
912 					case NLS:
913 					{
914 						sep();
915 						break;
916 					}
917 					case LITERAL_else:
918 					{
919 						break;
920 					}
921 					default:
922 					{
923 						throw new NoViableAltException(LT(1), getFilename());
924 					}
925 					}
926 					}
927 					match(LITERAL_else);
928 					}
929 				}
930 				catch (RecognitionException pe) {
931 					synPredMatched301 = false;
932 				}
933 				rewind(_m301);
934 inputState.guessing--;
935 			}
936 			if ( synPredMatched301 ) {
937 				{
938 				switch ( LA(1)) {
939 				case SEMI:
940 				case NLS:
941 				{
942 					sep();
943 					break;
944 				}
945 				case LITERAL_else:
946 				{
947 					break;
948 				}
949 				default:
950 				{
951 					throw new NoViableAltException(LT(1), getFilename());
952 				}
953 				}
954 				}
955 				match(LITERAL_else);
956 				nlsWarn();
957 				compatibleBodyStatement();
958 				elseCbs_AST = (AST)returnAST;
959 			}
960 previous bug bug overview next bug   			else if ((_tokenSet_10.member(LA(1))) && (_tokenSet_11.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
961 			}
962 			else {
963 				throw new NoViableAltException(LT(1), getFilename());
964 			}
965 			
966 			}
967 			if ( inputState.guessing==0 ) {
968 				statement_AST = (AST)currentAST.root;
969 				statement_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(LITERAL_if,"if",first,LT(1))).add(ale_AST).add(ifCbs_AST).add(elseCbs_AST));
970 				currentAST.root = statement_AST;
971 				currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?
972 					statement_AST.getFirstChild() : statement_AST;
973 				currentAST.advanceChildToEnd();
974 			}
975 			statement_AST = (AST)currentAST.root;
976 			break;
977 		}
978 		case LITERAL_for:
979 		{
980 			forStatement();
981 			astFactory.addASTChild(currentAST, returnAST);
982 			statement_AST = (AST)currentAST.root;
983 			break;
984 		}
985 		case LITERAL_while:
986 		{
987 			match(LITERAL_while);
988 			match(LPAREN);
989 			sce=strictContextExpression(false);
990 			while_sce_AST = (AST)returnAST;
991 			match(RPAREN);
992 previous bug bug overview next bug   			nlsWarn(); 
993 			{
994 			switch ( LA(1)) {
995 			case SEMI:
996 			{
997 				s = LT(1);
998 				s_AST = astFactory.create(s);
999 				match(SEMI);
1000 				break;
1001 			}
1002 			case FINAL:
1003 			case ABSTRACT:
1004 			case STRICTFP:
1005 			case LITERAL_import:
1006 			case LITERAL_static:
1007 			case LITERAL_def:
1008 			case LBRACK:
1009 			case IDENT:
1010 			case STRING_LITERAL:
1011 			case LPAREN:
1012 			case LITERAL_class:
1013 			case LITERAL_interface:
1014 			case LITERAL_enum:
1015 			case AT:
1016 			case LITERAL_super:
1017 			case LITERAL_void:
1018 			case LITERAL_boolean:
1019 			case LITERAL_byte:
1020 			case LITERAL_char:
1021 			case LITERAL_short:
1022 			case LITERAL_int:
1023 			case LITERAL_float:
1024 			case LITERAL_long:
1025 			case LITERAL_double:
1026 			case LITERAL_private:
1027 			case LITERAL_public:
1028 			case LITERAL_protected:
1029 			case LITERAL_transient:
1030 			case LITERAL_native:
1031 			case LITERAL_threadsafe:
1032 			case LITERAL_synchronized:
1033 			case LITERAL_volatile:
1034 			case LCURLY:
1035 			case LITERAL_this:
1036 			case LITERAL_if:
1037 			case LITERAL_while:
1038 			case LITERAL_switch:
1039 			case LITERAL_for:
1040 			case LITERAL_return:
1041 			case LITERAL_break:
1042 			case LITERAL_continue:
1043 			case LITERAL_throw:
1044 			case LITERAL_assert:
1045 			case PLUS:
1046 			case MINUS:
1047 			case LITERAL_try:
1048 			case LITERAL_false:
1049 			case LITERAL_new:
1050 			case LITERAL_null:
1051 			case LITERAL_true:
1052 			case INC:
1053 			case DEC:
1054 			case BNOT:
1055 			case LNOT:
1056 			case STRING_CTOR_START:
1057 			case NUM_INT:
1058 			case NUM_FLOAT:
1059 			case NUM_LONG:
1060 			case NUM_DOUBLE:
1061 			case NUM_BIG_INT:
1062 			case NUM_BIG_DECIMAL:
1063 			{
1064 				compatibleBodyStatement();
1065 				while_cbs_AST = (AST)returnAST;
1066 				break;
1067 			}
1068 			default:
1069 			{
1070 				throw new NoViableAltException(LT(1), getFilename());
1071 			}
1072 			}
1073 			}
1074 			if ( inputState.guessing==0 ) {
1075 				statement_AST = (AST)currentAST.root;
1076 				
1077 				if (s_AST != null)
1078 				statement_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(LITERAL_while,"Literal_while",first,LT(1))).add(while_sce_AST).add(s_AST));
1079 				else
1080 				statement_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(LITERAL_while,"Literal_while",first,LT(1))).add(while_sce_AST).add(while_cbs_AST));
1081 				
1082 				currentAST.root = statement_AST;
1083 				currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?
1084 					statement_AST.getFirstChild() : statement_AST;
1085 				currentAST.advanceChildToEnd();
1086 			}
1087 			statement_AST = (AST)currentAST.root;
1088 			break;
1089 		}
1090 		case LITERAL_switch:
1091 		{
1092 			match(LITERAL_switch);
1093 			match(LPAREN);
1094 			sce=strictContextExpression(false);
1095 			switchSce_AST = (AST)returnAST;
1096 			match(RPAREN);
1097 			nlsWarn();
1098 			match(LCURLY);
1099 			nls();
1100 			{
1101 			_loop307:
1102 			do {
1103 				if ((LA(1)==LITERAL_default||LA(1)==LITERAL_case)) {
1104 					casesGroup();
1105 					cg_AST = (AST)returnAST;
1106 					if ( inputState.guessing==0 ) {
1107 						casesGroup_AST = (AST)astFactory.make( (new ASTArray(3)).add(null).add(casesGroup_AST).add(cg_AST));
1108 					}
1109 				}
1110 				else {
1111 					break _loop307;
1112 				}
1113 				
1114 			} while (true);
1115 			}
1116 			match(RCURLY);
1117 			if ( inputState.guessing==0 ) {
1118 				statement_AST = (AST)currentAST.root;
1119 				statement_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(LITERAL_switch,"switch",first,LT(1))).add(switchSce_AST).add(casesGroup_AST));
1120 				currentAST.root = statement_AST;
1121 				currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?
1122 					statement_AST.getFirstChild() : statement_AST;
1123 				currentAST.advanceChildToEnd();
1124 			}
1125 			statement_AST = (AST)currentAST.root;
1126 			break;
1127 		}
1128 		case LITERAL_try:
1129 		{
1130 			tryBlock();
1131 			astFactory.addASTChild(currentAST, returnAST);
1132 			statement_AST = (AST)currentAST.root;
1133 			break;
1134 		}
1135 		case LITERAL_return:
1136 		case LITERAL_break:
1137 		case LITERAL_continue:
1138 		case LITERAL_throw:
1139 		case LITERAL_assert:
1140 		{
1141 			branchStatement();
1142 			astFactory.addASTChild(currentAST, returnAST);
1143 			statement_AST = (AST)currentAST.root;
1144 			break;
1145 		}
1146 		default:
1147 			boolean synPredMatched288 = false;
1148 			if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))))) {
1149 				int _m288 = mark();
1150 				synPredMatched288 = true;
1151 				inputState.guessing++;
1152 				try {
1153 					{
1154 					genericMethodStart();
1155 					}
1156 				}
1157 				catch (RecognitionException pe) {
1158 					synPredMatched288 = false;
1159 				}
1160 				rewind(_m288);
1161 inputState.guessing--;
1162 			}
1163 			if ( synPredMatched288 ) {
1164 				genericMethod();
1165 				astFactory.addASTChild(currentAST, returnAST);
1166 				statement_AST = (AST)currentAST.root;
1167 			}
1168 			else {
1169 				boolean synPredMatched290 = false;
1170 				if (((_tokenSet_12.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1171 					int _m290 = mark();
1172 					synPredMatched290 = true;
1173 					inputState.guessing++;
1174 					try {
1175 						{
1176 						multipleAssignmentDeclarationStart();
1177 						}
1178 					}
1179 					catch (RecognitionException pe) {
1180 						synPredMatched290 = false;
1181 					}
1182 					rewind(_m290);
1183 inputState.guessing--;
1184 				}
1185 				if ( synPredMatched290 ) {
1186 					multipleAssignmentDeclaration();
1187 					astFactory.addASTChild(currentAST, returnAST);
1188 					statement_AST = (AST)currentAST.root;
1189 				}
1190 				else {
1191 					boolean synPredMatched292 = false;
1192 					if (((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
1193 						int _m292 = mark();
1194 						synPredMatched292 = true;
1195 						inputState.guessing++;
1196 						try {
1197 							{
1198 							declarationStart();
1199 							}
1200 						}
1201 						catch (RecognitionException pe) {
1202 							synPredMatched292 = false;
1203 						}
1204 						rewind(_m292);
1205 inputState.guessing--;
1206 					}
1207 					if ( synPredMatched292 ) {
1208 						declaration();
1209 						astFactory.addASTChild(currentAST, returnAST);
1210 						statement_AST = (AST)currentAST.root;
1211 					}
1212 					else {
1213 						boolean synPredMatched294 = false;
1214 						if (((LA(1)==IDENT) && (LA(2)==COLON))) {
1215 							int _m294 = mark();
1216 							synPredMatched294 = true;
1217 							inputState.guessing++;
1218 							try {
1219 								{
1220 								match(IDENT);
1221 								match(COLON);
1222 								}
1223 							}
1224 							catch (RecognitionException pe) {
1225 								synPredMatched294 = false;
1226 							}
1227 							rewind(_m294);
1228 inputState.guessing--;
1229 						}
1230 						if ( synPredMatched294 ) {
1231 							statementLabelPrefix();
1232 							pfx_AST = (AST)returnAST;
1233 							if ( inputState.guessing==0 ) {
1234 								statement_AST = (AST)currentAST.root;
1235 								statement_AST = pfx_AST;
1236 								currentAST.root = statement_AST;
1237 								currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?
1238 									statement_AST.getFirstChild() : statement_AST;
1239 								currentAST.advanceChildToEnd();
1240 							}
1241 							{
1242 							boolean synPredMatched297 = false;
1243 							if (((LA(1)==LCURLY) && (_tokenSet_17.member(LA(2))))) {
1244 								int _m297 = mark();
1245 								synPredMatched297 = true;
1246 								inputState.guessing++;
1247 								try {
1248 									{
1249 									match(LCURLY);
1250 									}
1251 								}
1252 								catch (RecognitionException pe) {
1253 									synPredMatched297 = false;
1254 								}
1255 								rewind(_m297);
1256 inputState.guessing--;
1257 							}
1258 							if ( synPredMatched297 ) {
1259 								openOrClosableBlock();
1260 								astFactory.addASTChild(currentAST, returnAST);
1261 							}
1262 							else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
1263 								statement(COLON);
1264 								astFactory.addASTChild(currentAST, returnAST);
1265 							}
1266 							else {
1267 								throw new NoViableAltException(LT(1), getFilename());
1268 							}
1269 							
1270 							}
1271 							statement_AST = (AST)currentAST.root;
1272 						}
1273 						else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
1274 							expressionStatement(prevToken);
1275 							es_AST = (AST)returnAST;
1276 							astFactory.addASTChild(currentAST, returnAST);
1277 							statement_AST = (AST)currentAST.root;
1278 						}
1279 						else {
1280 							boolean synPredMatched305 = false;
1281 							if (((LA(1)==LITERAL_import||LA(1)==AT) && (_tokenSet_20.member(LA(2))))) {
1282 								int _m305 = mark();
1283 								synPredMatched305 = true;
1284 								inputState.guessing++;
1285 								try {
1286 									{
1287 									annotationsOpt();
1288 									match(LITERAL_import);
1289 									}
1290 								}
1291 								catch (RecognitionException pe) {
1292 									synPredMatched305 = false;
1293 								}
1294 								rewind(_m305);
1295 inputState.guessing--;
1296 							}
1297 							if ( synPredMatched305 ) {
1298 								importStatement();
1299 								astFactory.addASTChild(currentAST, returnAST);
1300 								statement_AST = (AST)currentAST.root;
1301 							}
1302 							else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1303 								modifiersOpt();
1304 								m_AST = (AST)returnAST;
1305 								typeDefinitionInternal(m_AST);
1306 								astFactory.addASTChild(currentAST, returnAST);
1307 								statement_AST = (AST)currentAST.root;
1308 							}
1309 							else if ((LA(1)==LITERAL_synchronized) && (LA(2)==LPAREN)) {
1310 								match(LITERAL_synchronized);
1311 								match(LPAREN);
1312 								sce=strictContextExpression(false);
1313 								synch_sce_AST = (AST)returnAST;
1314 								match(RPAREN);
1315 								nlsWarn();
1316 								compoundStatement();
1317 								synch_cs_AST = (AST)returnAST;
1318 								if ( inputState.guessing==0 ) {
1319 									statement_AST = (AST)currentAST.root;
1320 									statement_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(LITERAL_synchronized,"synchronized",first,LT(1))).add(synch_sce_AST).add(synch_cs_AST));
1321 									currentAST.root = statement_AST;
1322 									currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?
1323 										statement_AST.getFirstChild() : statement_AST;
1324 									currentAST.advanceChildToEnd();
1325 								}
1326 								statement_AST = (AST)currentAST.root;
1327 							}
1328 						else {
1329 							throw new NoViableAltException(LT(1), getFilename());
1330 						}
1331 						}}}}}
1332 						returnAST = statement_AST;
1333 					}
1334 					
1335 /** A statement separator is either a semicolon or a significant newline.
1336  *  Any number of additional (insignificant) newlines may accompany it.
1337  */
1338 	public final void sep() throws RecognitionException, TokenStreamException {
1339 		
1340 		returnAST = null;
1341 		ASTPair currentAST = new ASTPair();
1342 		AST sep_AST = null;
1343 		
1344 		switch ( LA(1)) {
1345 		case SEMI:
1346 		{
1347 			match(SEMI);
1348 			{
1349 			_loop573:
1350 			do {
1351 				if ((LA(1)==NLS) && (_tokenSet_23.member(LA(2)))) {
1352 					match(NLS);
1353 				}
1354 				else {
1355 					break _loop573;
1356 				}
1357 				
1358 			} while (true);
1359 			}
1360 			if ( inputState.guessing==0 ) {
1361 				sepToken = SEMI;
1362 			}
1363 			break;
1364 		}
1365 		case NLS:
1366 		{
1367 			match(NLS);
1368 			if ( inputState.guessing==0 ) {
1369 				sepToken = NLS;
1370 			}
1371 			{
1372 			_loop577:
1373 			do {
1374 				if ((LA(1)==SEMI) && (_tokenSet_23.member(LA(2)))) {
1375 					match(SEMI);
1376 					{
1377 					_loop576:
1378 					do {
1379 						if ((LA(1)==NLS) && (_tokenSet_23.member(LA(2)))) {
1380 							match(NLS);
1381 						}
1382 						else {
1383 							break _loop576;
1384 						}
1385 						
1386 					} while (true);
1387 					}
1388 					if ( inputState.guessing==0 ) {
1389 						sepToken = SEMI;
1390 					}
1391 				}
1392 				else {
1393 					break _loop577;
1394 				}
1395 				
1396 			} while (true);
1397 			}
1398 			break;
1399 		}
1400 		default:
1401 		{
1402 			throw new NoViableAltException(LT(1), getFilename());
1403 		}
1404 		}
1405 		returnAST = sep_AST;
1406 	}
1407 	
1408 /** A Groovy script or simple expression.  Can be anything legal inside {...}. */
1409 	public final void snippetUnit() throws RecognitionException, TokenStreamException {
1410 		
1411 		returnAST = null;
1412 		ASTPair currentAST = new ASTPair();
1413 		AST snippetUnit_AST = null;
1414 		
1415 		nls();
1416 		blockBody(EOF);
1417 		astFactory.addASTChild(currentAST, returnAST);
1418 		snippetUnit_AST = (AST)currentAST.root;
1419 		returnAST = snippetUnit_AST;
1420 	}
1421 	
1422 /** A block body is a parade of zero or more statements or expressions. */
1423 previous bug bug overview next bug   	public final void blockBody(  HEALTH4J >>  :  ExcessiveMethodLength 
1424 		int prevToken
1425 	) throws RecognitionException, TokenStreamException {
1426 		
1427 		returnAST = null;
1428 		ASTPair currentAST = new ASTPair();
1429 		AST blockBody_AST = null;
1430 		
1431 		{
1432 		switch ( LA(1)) {
1433 		case FINAL:
1434 		case ABSTRACT:
1435 		case STRICTFP:
1436 		case LITERAL_import:
1437 		case LITERAL_static:
1438 		case LITERAL_def:
1439 		case LBRACK:
1440 		case IDENT:
1441 		case STRING_LITERAL:
1442 		case LPAREN:
1443 		case LITERAL_class:
1444 		case LITERAL_interface:
1445 		case LITERAL_enum:
1446 		case AT:
1447 		case LITERAL_super:
1448 		case LITERAL_void:
1449 		case LITERAL_boolean:
1450 		case LITERAL_byte:
1451 		case LITERAL_char:
1452 		case LITERAL_short:
1453 		case LITERAL_int:
1454 		case LITERAL_float:
1455 		case LITERAL_long:
1456 		case LITERAL_double:
1457 		case LITERAL_private:
1458 		case LITERAL_public:
1459 		case LITERAL_protected:
1460 		case LITERAL_transient:
1461 		case LITERAL_native:
1462 		case LITERAL_threadsafe:
1463 		case LITERAL_synchronized:
1464 		case LITERAL_volatile:
1465 		case LCURLY:
1466 		case LITERAL_this:
1467 		case LITERAL_if:
1468 		case LITERAL_while:
1469 		case LITERAL_switch:
1470 		case LITERAL_for:
1471 		case LITERAL_return:
1472 		case LITERAL_break:
1473 		case LITERAL_continue:
1474 		case LITERAL_throw:
1475 		case LITERAL_assert:
1476 		case PLUS:
1477 		case MINUS:
1478 		case LITERAL_try:
1479 		case LITERAL_false:
1480 		case LITERAL_new:
1481 		case LITERAL_null:
1482 		case LITERAL_true:
1483 		case INC:
1484 		case DEC:
1485 		case BNOT:
1486 		case LNOT:
1487 		case STRING_CTOR_START:
1488 		case NUM_INT:
1489 		case NUM_FLOAT:
1490 		case NUM_LONG:
1491 		case NUM_DOUBLE:
1492 		case NUM_BIG_INT:
1493 		case NUM_BIG_DECIMAL:
1494 		{
1495 			statement(prevToken);
1496 			astFactory.addASTChild(currentAST, returnAST);
1497 			break;
1498 		}
1499 		case EOF:
1500 		case RCURLY:
1501 		case SEMI:
1502 		case NLS:
1503 		{
1504 			break;
1505 		}
1506 		default:
1507 		{
1508 			throw new NoViableAltException(LT(1), getFilename());
1509 		}
1510 		}
1511 		}
1512 		{
1513 		_loop282:
1514 		do {
1515 			if ((LA(1)==SEMI||LA(1)==NLS)) {
1516 				sep();
1517 				{
1518 				switch ( LA(1)) {
1519 				case FINAL:
1520 				case ABSTRACT:
1521 				case STRICTFP:
1522 				case LITERAL_import:
1523 				case LITERAL_static:
1524 				case LITERAL_def:
1525 				case LBRACK:
1526 				case IDENT:
1527 				case STRING_LITERAL:
1528 				case LPAREN:
1529 				case LITERAL_class:
1530 				case LITERAL_interface:
1531 				case LITERAL_enum:
1532 				case AT:
1533 				case LITERAL_super:
1534 				case LITERAL_void:
1535 				case LITERAL_boolean:
1536 				case LITERAL_byte:
1537 				case LITERAL_char:
1538 				case LITERAL_short:
1539 				case LITERAL_int:
1540 				case LITERAL_float:
1541 				case LITERAL_long:
1542 				case LITERAL_double:
1543 				case LITERAL_private:
1544 				case LITERAL_public:
1545 				case LITERAL_protected:
1546 				case LITERAL_transient:
1547 				case LITERAL_native:
1548 				case LITERAL_threadsafe:
1549 				case LITERAL_synchronized:
1550 				case LITERAL_volatile:
1551 				case LCURLY:
1552 				case LITERAL_this:
1553 				case LITERAL_if:
1554 				case LITERAL_while:
1555 				case LITERAL_switch:
1556 				case LITERAL_for:
1557 				case LITERAL_return:
1558 				case LITERAL_break:
1559 				case LITERAL_continue:
1560 				case LITERAL_throw:
1561 				case LITERAL_assert:
1562 				case PLUS:
1563 				case MINUS:
1564 				case LITERAL_try:
1565 				case LITERAL_false:
1566 				case LITERAL_new:
1567 				case LITERAL_null:
1568 				case LITERAL_true:
1569 				case INC:
1570 				case DEC:
1571 				case BNOT:
1572 				case LNOT:
1573 				case STRING_CTOR_START:
1574 				case NUM_INT:
1575 				case NUM_FLOAT:
1576 				case NUM_LONG:
1577 				case NUM_DOUBLE:
1578 				case NUM_BIG_INT:
1579 				case NUM_BIG_DECIMAL:
1580 				{
1581 					statement(sepToken);
1582 					astFactory.addASTChild(currentAST, returnAST);
1583 					break;
1584 				}
1585 				case EOF:
1586 				case RCURLY:
1587 				case SEMI:
1588 				case NLS:
1589 				{
1590 					break;
1591 				}
1592 				default:
1593 				{
1594 					throw new NoViableAltException(LT(1), getFilename());
1595 				}
1596 				}
1597 				}
1598 			}
1599 			else {
1600 				break _loop282;
1601 			}
1602 			
1603 		} while (true);
1604 		}
1605 		blockBody_AST = (AST)currentAST.root;
1606 		returnAST = blockBody_AST;
1607 	}
1608 	
1609 	public final void identifier() throws RecognitionException, TokenStreamException {
1610 		
1611 		returnAST = null;
1612 		ASTPair currentAST = new ASTPair();
1613 		AST identifier_AST = null;
1614 		Token  i1 = null;
1615 		AST i1_AST = null;
1616 		Token  d = null;
1617 		AST d_AST = null;
1618 		Token  i2 = null;
1619 		AST i2_AST = null;
1620 		Token first = LT(1);
1621 		
1622 		i1 = LT(1);
1623 		i1_AST = astFactory.create(i1);
1624 		match(IDENT);
1625 		{
1626 		_loop72:
1627 		do {
1628 			if ((LA(1)==DOT)) {
1629 				d = LT(1);
1630 				d_AST = astFactory.create(d);
1631 				match(DOT);
1632 				nls();
1633 				i2 = LT(1);
1634 				i2_AST = astFactory.create(i2);
1635 				match(IDENT);
1636 				if ( inputState.guessing==0 ) {
1637 					i1_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(DOT,".",first,LT(1))).add(i1_AST).add(i2_AST));
1638 				}
1639 			}
1640 			else {
1641 				break _loop72;
1642 			}
1643 			
1644 		} while (true);
1645 		}
1646 		if ( inputState.guessing==0 ) {
1647 			identifier_AST = (AST)currentAST.root;
1648 			identifier_AST = i1_AST;
1649 			currentAST.root = identifier_AST;
1650 			currentAST.child = identifier_AST!=null &&identifier_AST.getFirstChild()!=null ?
1651 				identifier_AST.getFirstChild() : identifier_AST;
1652 			currentAST.advanceChildToEnd();
1653 		}
1654 		identifier_AST = (AST)currentAST.root;
1655 		returnAST = identifier_AST;
1656 	}
1657 	
1658 	public final void importStatement() throws RecognitionException, TokenStreamException {
1659 		
1660 		returnAST = null;
1661 		ASTPair currentAST = new ASTPair();
1662 		AST importStatement_AST = null;
1663 		AST an_AST = null;
1664 		AST is_AST = null;
1665 		Token first = LT(1); boolean isStatic = false;
1666 		
1667 		annotationsOpt();
1668 		an_AST = (AST)returnAST;
1669 		astFactory.addASTChild(currentAST, returnAST);
1670 		match(LITERAL_import);
1671 		{
1672 		switch ( LA(1)) {
1673 		case LITERAL_static:
1674 		{
1675 			match(LITERAL_static);
1676 			if ( inputState.guessing==0 ) {
1677 				isStatic=true;
1678 			}
1679 			break;
1680 		}
1681 		case IDENT:
1682 		{
1683 			break;
1684 		}
1685 		default:
1686 		{
1687 			throw new NoViableAltException(LT(1), getFilename());
1688 		}
1689 		}
1690 		}
1691 		identifierStar();
1692 		is_AST = (AST)returnAST;
1693 		if ( inputState.guessing==0 ) {
1694 			importStatement_AST = (AST)currentAST.root;
1695 			if (isStatic)
1696 			importStatement_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(STATIC_IMPORT,"static_import",first,LT(1))).add(an_AST).add(is_AST));
1697 			else
1698 			importStatement_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(IMPORT,"import",first,LT(1))).add(an_AST).add(is_AST));
1699 			currentAST.root = importStatement_AST;
1700 			currentAST.child = importStatement_AST!=null &&importStatement_AST.getFirstChild()!=null ?
1701 				importStatement_AST.getFirstChild() : importStatement_AST;
1702 			currentAST.advanceChildToEnd();
1703 		}
1704 		importStatement_AST = (AST)currentAST.root;
1705 		returnAST = importStatement_AST;
1706 	}
1707 	
1708 previous bug bug overview next bug   	public final void identifierStar() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
1709 		
1710 		returnAST = null;
1711 		ASTPair currentAST = new ASTPair();
1712 		AST identifierStar_AST = null;
1713 		Token  i1 = null;
1714 		AST i1_AST = null;
1715 		Token  d1 = null;
1716 		AST d1_AST = null;
1717 		Token  i2 = null;
1718 		AST i2_AST = null;
1719 		Token  d2 = null;
1720 		AST d2_AST = null;
1721 		Token  s = null;
1722 		AST s_AST = null;
1723 		Token  alias = null;
1724 		AST alias_AST = null;
1725 		Token first = LT(1);
1726 		
1727 		i1 = LT(1);
1728 		i1_AST = astFactory.create(i1);
1729 		match(IDENT);
1730 		{
1731 		_loop75:
1732 		do {
1733 			if ((LA(1)==DOT) && (LA(2)==IDENT||LA(2)==NLS)) {
1734 				d1 = LT(1);
1735 				d1_AST = astFactory.create(d1);
1736 				match(DOT);
1737 				nls();
1738 				i2 = LT(1);
1739 				i2_AST = astFactory.create(i2);
1740 				match(IDENT);
1741 				if ( inputState.guessing==0 ) {
1742 					i1_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(DOT,".",first,LT(1))).add(i1_AST).add(i2_AST));
1743 				}
1744 			}
1745 			else {
1746 				break _loop75;
1747 			}
1748 			
1749 		} while (true);
1750 		}
1751 		{
1752 		switch ( LA(1)) {
1753 		case DOT:
1754 		{
1755 			d2 = LT(1);
1756 			d2_AST = astFactory.create(d2);
1757 			match(DOT);
1758 			nls();
1759 			s = LT(1);
1760 			s_AST = astFactory.create(s);
1761 			match(STAR);
1762 			if ( inputState.guessing==0 ) {
1763 				i1_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(DOT,".",first,LT(1))).add(i1_AST).add(s_AST));
1764 			}
1765 			break;
1766 		}
1767 		case LITERAL_as:
1768 		{
1769 			match(LITERAL_as);
1770 			nls();
1771 			alias = LT(1);
1772 			alias_AST = astFactory.create(alias);
1773 			match(IDENT);
1774 			if ( inputState.guessing==0 ) {
1775 				i1_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(LITERAL_as,"as",first,LT(1))).add(i1_AST).add(alias_AST));
1776 			}
1777 			break;
1778 		}
1779 		case EOF:
1780 		case RCURLY:
1781 		case SEMI:
1782 		case LITERAL_default:
1783 		case LITERAL_else:
1784 		case LITERAL_case:
1785 		case NLS:
1786 		{
1787 			break;
1788 		}
1789 		default:
1790 		{
1791 			throw new NoViableAltException(LT(1), getFilename());
1792 		}
1793 		}
1794 		}
1795 		if ( inputState.guessing==0 ) {
1796 			identifierStar_AST = (AST)currentAST.root;
1797 			identifierStar_AST = i1_AST;
1798 			currentAST.root = identifierStar_AST;
1799 			currentAST.child = identifierStar_AST!=null &&identifierStar_AST.getFirstChild()!=null ?
1800 				identifierStar_AST.getFirstChild() : identifierStar_AST;
1801 			currentAST.advanceChildToEnd();
1802 		}
1803 		identifierStar_AST = (AST)currentAST.root;
1804 		returnAST = identifierStar_AST;
1805 	}
1806 	
1807 	protected final void typeDefinitionInternal(
1808 		AST mods
1809 	) throws RecognitionException, TokenStreamException {
1810 		
1811 		returnAST = null;
1812 		ASTPair currentAST = new ASTPair();
1813 		AST typeDefinitionInternal_AST = null;
1814 		AST cd_AST = null;
1815 		AST id_AST = null;
1816 		AST ed_AST = null;
1817 		AST ad_AST = null;
1818 		
1819 		switch ( LA(1)) {
1820 		case LITERAL_class:
1821 		{
1822 			classDefinition(mods);
1823 			cd_AST = (AST)returnAST;
1824 			astFactory.addASTChild(currentAST, returnAST);
1825 			if ( inputState.guessing==0 ) {
1826 				typeDefinitionInternal_AST = (AST)currentAST.root;
1827 				typeDefinitionInternal_AST = cd_AST;
1828 				currentAST.root = typeDefinitionInternal_AST;
1829 				currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
1830 					typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
1831 				currentAST.advanceChildToEnd();
1832 			}
1833 			typeDefinitionInternal_AST = (AST)currentAST.root;
1834 			break;
1835 		}
1836 		case LITERAL_interface:
1837 		{
1838 			interfaceDefinition(mods);
1839 			id_AST = (AST)returnAST;
1840 			astFactory.addASTChild(currentAST, returnAST);
1841 			if ( inputState.guessing==0 ) {
1842 				typeDefinitionInternal_AST = (AST)currentAST.root;
1843 				typeDefinitionInternal_AST = id_AST;
1844 				currentAST.root = typeDefinitionInternal_AST;
1845 				currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
1846 					typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
1847 				currentAST.advanceChildToEnd();
1848 			}
1849 			typeDefinitionInternal_AST = (AST)currentAST.root;
1850 			break;
1851 		}
1852 		case LITERAL_enum:
1853 		{
1854 			enumDefinition(mods);
1855 			ed_AST = (AST)returnAST;
1856 			astFactory.addASTChild(currentAST, returnAST);
1857 			if ( inputState.guessing==0 ) {
1858 				typeDefinitionInternal_AST = (AST)currentAST.root;
1859 				typeDefinitionInternal_AST = ed_AST;
1860 				currentAST.root = typeDefinitionInternal_AST;
1861 				currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
1862 					typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
1863 				currentAST.advanceChildToEnd();
1864 			}
1865 			typeDefinitionInternal_AST = (AST)currentAST.root;
1866 			break;
1867 		}
1868 		case AT:
1869 		{
1870 			annotationDefinition(mods);
1871 			ad_AST = (AST)returnAST;
1872 			astFactory.addASTChild(currentAST, returnAST);
1873 			if ( inputState.guessing==0 ) {
1874 				typeDefinitionInternal_AST = (AST)currentAST.root;
1875 				typeDefinitionInternal_AST = ad_AST;
1876 				currentAST.root = typeDefinitionInternal_AST;
1877 				currentAST.child = typeDefinitionInternal_AST!=null &&typeDefinitionInternal_AST.getFirstChild()!=null ?
1878 					typeDefinitionInternal_AST.getFirstChild() : typeDefinitionInternal_AST;
1879 				currentAST.advanceChildToEnd();
1880 			}
1881 			typeDefinitionInternal_AST = (AST)currentAST.root;
1882 			break;
1883 		}
1884 		default:
1885 		{
1886 			throw new NoViableAltException(LT(1), getFilename());
1887 		}
1888 		}
1889 		returnAST = typeDefinitionInternal_AST;
1890 	}
1891 	
1892 previous bug bug overview next bug   	public final void classDefinition(  HEALTH4J >>  :  health.MissingJavaDoc 
1893 		AST modifiers
1894 	) throws RecognitionException, TokenStreamException {
1895 		
1896 		returnAST = null;
1897 		ASTPair currentAST = new ASTPair();
1898 		AST classDefinition_AST = null;
1899 		AST tp_AST = null;
1900 		AST sc_AST = null;
1901 		AST ic_AST = null;
1902 		AST cb_AST = null;
1903 		Token first = cloneToken(LT(1));AST prevCurrentClass = currentClass;
1904 		if (modifiers != null) {
1905 		first.setLine(modifiers.getLine());
1906 		first.setColumn(modifiers.getColumn());
1907 		}
1908 		
1909 		match(LITERAL_class);
1910 		AST tmp29_AST = null;
1911 		tmp29_AST = astFactory.create(LT(1));
1912 		match(IDENT);
1913 		nls();
1914 		if ( inputState.guessing==0 ) {
1915 			currentClass = tmp29_AST;
1916 		}
1917 		{
1918 		switch ( LA(1)) {
1919 		case LT:
1920 		{
1921 			typeParameters();
1922 			tp_AST = (AST)returnAST;
1923 			nls();
1924 			break;
1925 		}
1926 		case LITERAL_extends:
1927 		case LCURLY:
1928 		case LITERAL_implements:
1929 		{
1930 			break;
1931 		}
1932 		default:
1933 		{
1934 			throw new NoViableAltException(LT(1), getFilename());
1935 		}
1936 		}
1937 		}
1938 		superClassClause();
1939 		sc_AST = (AST)returnAST;
1940 		implementsClause();
1941 		ic_AST = (AST)returnAST;
1942 		classBlock();
1943 		cb_AST = (AST)returnAST;
1944 		if ( inputState.guessing==0 ) {
1945 			classDefinition_AST = (AST)currentAST.root;
1946 			classDefinition_AST = (AST)astFactory.make( (new ASTArray(7)).add(create(CLASS_DEF,"CLASS_DEF",first,LT(1))).add(modifiers).add(tmp29_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(cb_AST));
1947 			currentAST.root = classDefinition_AST;
1948 			currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ?
1949 				classDefinition_AST.getFirstChild() : classDefinition_AST;
1950 			currentAST.advanceChildToEnd();
1951 		}
1952 		if ( inputState.guessing==0 ) {
1953 			currentClass = prevCurrentClass;
1954 		}
1955 		returnAST = classDefinition_AST;
1956 	}
1957 	
1958 previous bug bug overview next bug   	public final void interfaceDefinition(  HEALTH4J >>  :  health.MissingJavaDoc 
1959 		AST modifiers
1960 	) throws RecognitionException, TokenStreamException {
1961 		
1962 		returnAST = null;
1963 		ASTPair currentAST = new ASTPair();
1964 		AST interfaceDefinition_AST = null;
1965 		AST tp_AST = null;
1966 		AST ie_AST = null;
1967 		AST ib_AST = null;
1968 		Token first = cloneToken(LT(1));
1969 		if (modifiers != null) {
1970 		first.setLine(modifiers.getLine());
1971 		first.setColumn(modifiers.getColumn());
1972 		}
1973 		
1974 		match(LITERAL_interface);
1975 		AST tmp31_AST = null;
1976 		tmp31_AST = astFactory.create(LT(1));
1977 		match(IDENT);
1978 		nls();
1979 		{
1980 		switch ( LA(1)) {
1981 		case LT:
1982 		{
1983 			typeParameters();
1984 			tp_AST = (AST)returnAST;
1985 			nls();
1986 			break;
1987 		}
1988 		case LITERAL_extends:
1989 		case LCURLY:
1990 		{
1991 			break;
1992 		}
1993 		default:
1994 		{
1995 			throw new NoViableAltException(LT(1), getFilename());
1996 		}
1997 		}
1998 		}
1999 		interfaceExtends();
2000 		ie_AST = (AST)returnAST;
2001 		interfaceBlock();
2002 		ib_AST = (AST)returnAST;
2003 		if ( inputState.guessing==0 ) {
2004 			interfaceDefinition_AST = (AST)currentAST.root;
2005 			interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(create(INTERFACE_DEF,"INTERFACE_DEF",first,LT(1))).add(modifiers).add(tmp31_AST).add(tp_AST).add(ie_AST).add(ib_AST));
2006 			currentAST.root = interfaceDefinition_AST;
2007 			currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ?
2008 				interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST;
2009 			currentAST.advanceChildToEnd();
2010 		}
2011 		returnAST = interfaceDefinition_AST;
2012 	}
2013 	
2014 	public final void enumDefinition(
2015 		AST modifiers
2016 	) throws RecognitionException, TokenStreamException {
2017 		
2018 		returnAST = null;
2019 		ASTPair currentAST = new ASTPair();
2020 		AST enumDefinition_AST = null;
2021 		AST ic_AST = null;
2022 		AST eb_AST = null;
2023 		Token first = cloneToken(LT(1)); AST prevCurrentClass = currentClass;
2024 		if (modifiers != null) {
2025 		first.setLine(modifiers.getLine());
2026 		first.setColumn(modifiers.getColumn());
2027 		}
2028 		
2029 		match(LITERAL_enum);
2030 		AST tmp33_AST = null;
2031 		tmp33_AST = astFactory.create(LT(1));
2032 		match(IDENT);
2033 		if ( inputState.guessing==0 ) {
2034 			currentClass = tmp33_AST;
2035 		}
2036 		nls();
2037 		implementsClause();
2038 		ic_AST = (AST)returnAST;
2039 		nls();
2040 		enumBlock();
2041 		eb_AST = (AST)returnAST;
2042 		if ( inputState.guessing==0 ) {
2043 			enumDefinition_AST = (AST)currentAST.root;
2044 			enumDefinition_AST = (AST)astFactory.make( (new ASTArray(5)).add(create(ENUM_DEF,"ENUM_DEF",first,LT(1))).add(modifiers).add(tmp33_AST).add(ic_AST).add(eb_AST));
2045 			currentAST.root = enumDefinition_AST;
2046 			currentAST.child = enumDefinition_AST!=null &&enumDefinition_AST.getFirstChild()!=null ?
2047 				enumDefinition_AST.getFirstChild() : enumDefinition_AST;
2048 			currentAST.advanceChildToEnd();
2049 		}
2050 		if ( inputState.guessing==0 ) {
2051 			currentClass = prevCurrentClass;
2052 		}
2053 		returnAST = enumDefinition_AST;
2054 	}
2055 	
2056 	public final void annotationDefinition(
2057 		AST modifiers
2058 	) throws RecognitionException, TokenStreamException {
2059 		
2060 		returnAST = null;
2061 		ASTPair currentAST = new ASTPair();
2062 		AST annotationDefinition_AST = null;
2063 		AST ab_AST = null;
2064 		Token first = cloneToken(LT(1));
2065 		if (modifiers != null) {
2066 		first.setLine(modifiers.getLine());
2067 		first.setColumn(modifiers.getColumn());
2068 		}
2069 		
2070 		AST tmp34_AST = null;
2071 		tmp34_AST = astFactory.create(LT(1));
2072 		match(AT);
2073 		match(LITERAL_interface);
2074 		AST tmp36_AST = null;
2075 		tmp36_AST = astFactory.create(LT(1));
2076 		match(IDENT);
2077 		annotationBlock();
2078 		ab_AST = (AST)returnAST;
2079 		if ( inputState.guessing==0 ) {
2080 			annotationDefinition_AST = (AST)currentAST.root;
2081 			annotationDefinition_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(ANNOTATION_DEF,"ANNOTATION_DEF",first,LT(1))).add(modifiers).add(tmp36_AST).add(ab_AST));
2082 			currentAST.root = annotationDefinition_AST;
2083 			currentAST.child = annotationDefinition_AST!=null &&annotationDefinition_AST.getFirstChild()!=null ?
2084 				annotationDefinition_AST.getFirstChild() : annotationDefinition_AST;
2085 			currentAST.advanceChildToEnd();
2086 		}
2087 		returnAST = annotationDefinition_AST;
2088 	}
2089 	
2090 /** A declaration is the creation of a reference or primitive-type variable,
2091  *  or (if arguments are present) of a method.
2092  *  Generically, this is called a 'variable' definition, even in the case of a class field or method.
2093  *  It may start with the modifiers and/or a declaration keyword "def".
2094  *  It may also start with the modifiers and a capitalized type name.
2095  *  <p>
2096  *  AST effect: Create a separate Type/Var tree for each var in the var list.
2097  *  Must be guarded, as in (declarationStart) => declaration.
2098  */
2099 	public final void declaration() throws RecognitionException, TokenStreamException {
2100 		
2101 		returnAST = null;
2102 		ASTPair currentAST = new ASTPair();
2103 		AST declaration_AST = null;
2104 		AST m_AST = null;
2105 		AST t_AST = null;
2106 		AST v_AST = null;
2107 		AST t2_AST = null;
2108 		AST v2_AST = null;
2109 		
2110 		switch ( LA(1)) {
2111 		case FINAL:
2112 		case ABSTRACT:
2113 		case STRICTFP:
2114 		case LITERAL_static:
2115 		case LITERAL_def:
2116 		case AT:
2117 		case LITERAL_private:
2118 		case LITERAL_public:
2119 		case LITERAL_protected:
2120 		case LITERAL_transient:
2121 		case LITERAL_native:
2122 		case LITERAL_threadsafe:
2123 		case LITERAL_synchronized:
2124 		case LITERAL_volatile:
2125 		{
2126 			modifiers();
2127 			m_AST = (AST)returnAST;
2128 			{
2129 			if ((_tokenSet_24.member(LA(1))) && (_tokenSet_25.member(LA(2)))) {
2130 				typeSpec(false);
2131 				t_AST = (AST)returnAST;
2132 			}
2133 previous bug bug overview next bug   			else if ((LA(1)==IDENT||LA(1)==STRING_LITERAL) && (_tokenSet_26.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
2134 			}
2135 			else {
2136 				throw new NoViableAltException(LT(1), getFilename());
2137 			}
2138 			
2139 			}
2140 			variableDefinitions(m_AST, t_AST);
2141 			v_AST = (AST)returnAST;
2142 			if ( inputState.guessing==0 ) {
2143 				declaration_AST = (AST)currentAST.root;
2144 				declaration_AST = v_AST;
2145 				currentAST.root = declaration_AST;
2146 				currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
2147 					declaration_AST.getFirstChild() : declaration_AST;
2148 				currentAST.advanceChildToEnd();
2149 			}
2150 			break;
2151 		}
2152 		case IDENT:
2153 		case LITERAL_void:
2154 		case LITERAL_boolean:
2155 		case LITERAL_byte:
2156 		case LITERAL_char:
2157 		case LITERAL_short:
2158 		case LITERAL_int:
2159 		case LITERAL_float:
2160 		case LITERAL_long:
2161 		case LITERAL_double:
2162 		{
2163 			typeSpec(false);
2164 			t2_AST = (AST)returnAST;
2165 			variableDefinitions(null,t2_AST);
2166 			v2_AST = (AST)returnAST;
2167 			if ( inputState.guessing==0 ) {
2168 				declaration_AST = (AST)currentAST.root;
2169 				declaration_AST = v2_AST;
2170 				currentAST.root = declaration_AST;
2171 				currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
2172 					declaration_AST.getFirstChild() : declaration_AST;
2173 				currentAST.advanceChildToEnd();
2174 			}
2175 			break;
2176 		}
2177 		default:
2178 		{
2179 			throw new NoViableAltException(LT(1), getFilename());
2180 		}
2181 		}
2182 		returnAST = declaration_AST;
2183 	}
2184 	
2185 /** A list of one or more modifier, annotation, or "def". */
2186 	public final void modifiers() throws RecognitionException, TokenStreamException {
2187 		
2188 		returnAST = null;
2189 		ASTPair currentAST = new ASTPair();
2190 		AST modifiers_AST = null;
2191 		Token first = LT(1);
2192 		
2193 		modifiersInternal();
2194 		astFactory.addASTChild(currentAST, returnAST);
2195 		if ( inputState.guessing==0 ) {
2196 			modifiers_AST = (AST)currentAST.root;
2197 			modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(MODIFIERS,"MODIFIERS",first,LT(1))).add(modifiers_AST));
2198 			currentAST.root = modifiers_AST;
2199 			currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ?
2200 				modifiers_AST.getFirstChild() : modifiers_AST;
2201 			currentAST.advanceChildToEnd();
2202 		}
2203 		modifiers_AST = (AST)currentAST.root;
2204 		returnAST = modifiers_AST;
2205 	}
2206 	
2207 	public final void typeSpec(
2208 		boolean addImagNode
2209 	) throws RecognitionException, TokenStreamException {
2210 		
2211 		returnAST = null;
2212 		ASTPair currentAST = new ASTPair();
2213 		AST typeSpec_AST = null;
2214 		
2215 		switch ( LA(1)) {
2216 		case IDENT:
2217 		{
2218 			classTypeSpec(addImagNode);
2219 			astFactory.addASTChild(currentAST, returnAST);
2220 			typeSpec_AST = (AST)currentAST.root;
2221 			break;
2222 		}
2223 		case LITERAL_void:
2224 		case LITERAL_boolean:
2225 		case LITERAL_byte:
2226 		case LITERAL_char:
2227 		case LITERAL_short:
2228 		case LITERAL_int:
2229 		case LITERAL_float:
2230 		case LITERAL_long:
2231 		case LITERAL_double:
2232 		{
2233 			builtInTypeSpec(addImagNode);
2234 			astFactory.addASTChild(currentAST, returnAST);
2235 			typeSpec_AST = (AST)currentAST.root;
2236 			break;
2237 		}
2238 		default:
2239 		{
2240 			throw new NoViableAltException(LT(1), getFilename());
2241 		}
2242 		}
2243 		returnAST = typeSpec_AST;
2244 	}
2245 	
2246 /** The tail of a declaration.
2247   * Either v1, v2, ... (with possible initializers) or else m(args){body}.
2248   * The two arguments are the modifier list (if any) and the declaration head (if any).
2249   * The declaration head is the variable type, or (for a method) the return type.
2250   * If it is missing, then the variable type is taken from its initializer (if there is one).
2251   * Otherwise, the variable type defaults to 'any'.
2252   * DECIDE:  Method return types default to the type of the method body, as an expression.
2253   */
2254 	public final void variableDefinitions(
2255 		AST mods, AST t
2256 	) throws RecognitionException, TokenStreamException {
2257 		
2258 		returnAST = null;
2259 		ASTPair currentAST = new ASTPair();
2260 		AST variableDefinitions_AST = null;
2261 		Token  id = null;
2262 		AST id_AST = null;
2263 		Token  qid = null;
2264 		AST qid_AST = null;
2265 		AST param_AST = null;
2266 		AST tc_AST = null;
2267 		AST mb_AST = null;
2268 		Token first = cloneToken(LT(1));
2269 		if (mods != null) {
2270 		first.setLine(mods.getLine());
2271 		first.setColumn(mods.getColumn());
2272 		} else if (t != null) {
2273 		first.setLine(t.getLine());
2274 		first.setColumn(t.getColumn());
2275 		}
2276 		
2277 		if ((LA(1)==IDENT) && (_tokenSet_27.member(LA(2)))) {
2278 			listOfVariables(mods,t,first);
2279 			astFactory.addASTChild(currentAST, returnAST);
2280 			variableDefinitions_AST = (AST)currentAST.root;
2281 		}
2282 		else if ((LA(1)==IDENT||LA(1)==STRING_LITERAL) && (LA(2)==LPAREN)) {
2283 			{
2284 			switch ( LA(1)) {
2285 			case IDENT:
2286 			{
2287 				id = LT(1);
2288 				id_AST = astFactory.create(id);
2289 				astFactory.addASTChild(currentAST, id_AST);
2290 				match(IDENT);
2291 				break;
2292 			}
2293 			case STRING_LITERAL:
2294 			{
2295 				qid = LT(1);
2296 				qid_AST = astFactory.create(qid);
2297 				astFactory.addASTChild(currentAST, qid_AST);
2298 				match(STRING_LITERAL);
2299 				if ( inputState.guessing==0 ) {
2300 					qid_AST.setType(IDENT);
2301 				}
2302 				break;
2303 			}
2304 			default:
2305 			{
2306 				throw new NoViableAltException(LT(1), getFilename());
2307 			}
2308 			}
2309 			}
2310 			match(LPAREN);
2311 			parameterDeclarationList();
2312 			param_AST = (AST)returnAST;
2313 			match(RPAREN);
2314 			{
2315 			boolean synPredMatched233 = false;
2316 			if (((LA(1)==LITERAL_throws||LA(1)==NLS) && (_tokenSet_28.member(LA(2))))) {
2317 				int _m233 = mark();
2318 				synPredMatched233 = true;
2319 				inputState.guessing++;
2320 				try {
2321 					{
2322 					nls();
2323 					match(LITERAL_throws);
2324 					}
2325 				}
2326 				catch (RecognitionException pe) {
2327 					synPredMatched233 = false;
2328 				}
2329 				rewind(_m233);
2330 inputState.guessing--;
2331 			}
2332 			if ( synPredMatched233 ) {
2333 				throwsClause();
2334 				tc_AST = (AST)returnAST;
2335 			}
2336 previous bug bug overview next bug   			else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_11.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
2337 			}
2338 			else {
2339 				throw new NoViableAltException(LT(1), getFilename());
2340 			}
2341 			
2342 			}
2343 			{
2344 			boolean synPredMatched236 = false;
2345 			if (((LA(1)==LCURLY||LA(1)==NLS) && (_tokenSet_30.member(LA(2))))) {
2346 				int _m236 = mark();
2347 				synPredMatched236 = true;
2348 				inputState.guessing++;
2349 				try {
2350 					{
2351 					nls();
2352 					match(LCURLY);
2353 					}
2354 				}
2355 				catch (RecognitionException pe) {
2356 					synPredMatched236 = false;
2357 				}
2358 				rewind(_m236);
2359 inputState.guessing--;
2360 			}
2361 			if ( synPredMatched236 ) {
2362 				{
2363 				nlsWarn();
2364 				openBlock();
2365 				mb_AST = (AST)returnAST;
2366 				}
2367 			}
2368 previous bug bug overview next bug   			else if ((_tokenSet_10.member(LA(1))) && (_tokenSet_11.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
2369 			}
2370 			else {
2371 				throw new NoViableAltException(LT(1), getFilename());
2372 			}
2373 			
2374 			}
2375 			if ( inputState.guessing==0 ) {
2376 				variableDefinitions_AST = (AST)currentAST.root;
2377 				if (qid_AST != null)  id_AST = qid_AST;
2378 				variableDefinitions_AST =
2379 				(AST)astFactory.make( (new ASTArray(7)).add(create(METHOD_DEF,"METHOD_DEF",first,LT(1))).add(mods).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(t))).add(id_AST).add(param_AST).add(tc_AST).add(mb_AST));
2380 				
2381 				currentAST.root = variableDefinitions_AST;
2382 				currentAST.child = variableDefinitions_AST!=null &&variableDefinitions_AST.getFirstChild()!=null ?
2383 					variableDefinitions_AST.getFirstChild() : variableDefinitions_AST;
2384 				currentAST.advanceChildToEnd();
2385 			}
2386 			variableDefinitions_AST = (AST)currentAST.root;
2387 		}
2388 		else {
2389 			throw new NoViableAltException(LT(1), getFilename());
2390 		}
2391 		
2392 		returnAST = variableDefinitions_AST;
2393 	}
2394 	
2395 	public final void genericMethod() throws RecognitionException, TokenStreamException {
2396 		
2397 		returnAST = null;
2398 		ASTPair currentAST = new ASTPair();
2399 		AST genericMethod_AST = null;
2400 		AST m_AST = null;
2401 		AST p_AST = null;
2402 		AST t_AST = null;
2403 		AST v_AST = null;
2404 		
2405 		modifiers();
2406 		m_AST = (AST)returnAST;
2407 		typeParameters();
2408 		p_AST = (AST)returnAST;
2409 		typeSpec(false);
2410 		t_AST = (AST)returnAST;
2411 		variableDefinitions(m_AST, t_AST);
2412 		v_AST = (AST)returnAST;
2413 		if ( inputState.guessing==0 ) {
2414 			genericMethod_AST = (AST)currentAST.root;
2415 			
2416 			genericMethod_AST = v_AST;
2417 previous bug bug overview next bug   			AST old = v_AST.getFirstChild();  HEALTH4J >>  :  RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE 
2418 			genericMethod_AST.setFirstChild(p_AST);
2419 			p_AST.setNextSibling(old);
2420 			
2421 			currentAST.root = genericMethod_AST;
2422 			currentAST.child = genericMethod_AST!=null &&genericMethod_AST.getFirstChild()!=null ?
2423 				genericMethod_AST.getFirstChild() : genericMethod_AST;
2424 			currentAST.advanceChildToEnd();
2425 		}
2426 		returnAST = genericMethod_AST;
2427 	}
2428 	
2429 previous bug bug overview next bug   	public final void typeParameters() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
2430 		
2431 		returnAST = null;
2432 		ASTPair currentAST = new ASTPair();
2433 		AST typeParameters_AST = null;
2434 		Token first = LT(1);int currentLtLevel = 0;
2435 		
2436 		if ( inputState.guessing==0 ) {
2437 			currentLtLevel = ltCounter;
2438 		}
2439 		match(LT);
2440 		if ( inputState.guessing==0 ) {
2441 			ltCounter++;
2442 		}
2443 		nls();
2444 		typeParameter();
2445 		astFactory.addASTChild(currentAST, returnAST);
2446 		{
2447 		_loop110:
2448 		do {
2449 			if ((LA(1)==COMMA)) {
2450 				match(COMMA);
2451 				nls();
2452 				typeParameter();
2453 				astFactory.addASTChild(currentAST, returnAST);
2454 			}
2455 			else {
2456 				break _loop110;
2457 			}
2458 			
2459 		} while (true);
2460 		}
2461 		nls();
2462 		{
2463 		switch ( LA(1)) {
2464 		case GT:
2465 		case SR:
2466 		case BSR:
2467 		{
2468 			typeArgumentsOrParametersEnd();
2469 			astFactory.addASTChild(currentAST, returnAST);
2470 			break;
2471 		}
2472 		case IDENT:
2473 		case LITERAL_extends:
2474 		case LITERAL_void:
2475 		case LITERAL_boolean:
2476 		case LITERAL_byte:
2477 		case LITERAL_char:
2478 		case LITERAL_short:
2479 		case LITERAL_int:
2480 		case LITERAL_float:
2481 		case LITERAL_long:
2482 		case LITERAL_double:
2483 		case LCURLY:
2484 		case LITERAL_implements:
2485 		case NLS:
2486 		{
2487 			break;
2488 		}
2489 		default:
2490 		{
2491 			throw new NoViableAltException(LT(1), getFilename());
2492 		}
2493 		}
2494 		}
2495 		if (!(matchGenericTypeBrackets(((currentLtLevel != 0) || ltCounter == currentLtLevel),
2496         "Missing closing bracket '>' for generics types", "Please specify the missing bracket!")))
2497 		  throw new SemanticException("matchGenericTypeBrackets(((currentLtLevel != 0) || ltCounter == currentLtLevel),\n        \"Missing closing bracket '>' for generics types\", \"Please specify the missing bracket!\")");
2498 		if ( inputState.guessing==0 ) {
2499 			typeParameters_AST = (AST)currentAST.root;
2500 			typeParameters_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_PARAMETERS,"TYPE_PARAMETERS",first,LT(1))).add(typeParameters_AST));
2501 			currentAST.root = typeParameters_AST;
2502 			currentAST.child = typeParameters_AST!=null &&typeParameters_AST.getFirstChild()!=null ?
2503 				typeParameters_AST.getFirstChild() : typeParameters_AST;
2504 			currentAST.advanceChildToEnd();
2505 		}
2506 		typeParameters_AST = (AST)currentAST.root;
2507 		returnAST = typeParameters_AST;
2508 	}
2509 	
2510 /** A declaration with one declarator and no initialization, like a parameterDeclaration.
2511  *  Used to parse loops like <code>for (int x in y)</code> (up to the <code>in</code> keyword).
2512  */
2513 	public final void singleDeclarationNoInit() throws RecognitionException, TokenStreamException {
2514 		
2515 		returnAST = null;
2516 		ASTPair currentAST = new ASTPair();
2517 		AST singleDeclarationNoInit_AST = null;
2518 		AST m_AST = null;
2519 		AST t_AST = null;
2520 		AST v_AST = null;
2521 		AST t2_AST = null;
2522 		AST v2_AST = null;
2523 		
2524 		switch ( LA(1)) {
2525 		case FINAL:
2526 		case ABSTRACT:
2527 		case STRICTFP:
2528 		case LITERAL_static:
2529 		case LITERAL_def:
2530 		case AT:
2531 		case LITERAL_private:
2532 		case LITERAL_public:
2533 		case LITERAL_protected:
2534 		case LITERAL_transient:
2535 		case LITERAL_native:
2536 		case LITERAL_threadsafe:
2537 		case LITERAL_synchronized:
2538 		case LITERAL_volatile:
2539 		{
2540 			modifiers();
2541 			m_AST = (AST)returnAST;
2542 			{
2543 			if ((_tokenSet_24.member(LA(1))) && (_tokenSet_31.member(LA(2)))) {
2544 				typeSpec(false);
2545 				t_AST = (AST)returnAST;
2546 			}
2547 previous bug bug overview next bug   			else if ((LA(1)==IDENT) && (_tokenSet_32.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
2548 			}
2549 			else {
2550 				throw new NoViableAltException(LT(1), getFilename());
2551 			}
2552 			
2553 			}
2554 			singleVariable(m_AST, t_AST);
2555 			v_AST = (AST)returnAST;
2556 			if ( inputState.guessing==0 ) {
2557 				singleDeclarationNoInit_AST = (AST)currentAST.root;
2558 				singleDeclarationNoInit_AST = v_AST;
2559 				currentAST.root = singleDeclarationNoInit_AST;
2560 				currentAST.child = singleDeclarationNoInit_AST!=null &&singleDeclarationNoInit_AST.getFirstChild()!=null ?
2561 					singleDeclarationNoInit_AST.getFirstChild() : singleDeclarationNoInit_AST;
2562 				currentAST.advanceChildToEnd();
2563 			}
2564 			break;
2565 		}
2566 		case IDENT:
2567 		case LITERAL_void:
2568 		case LITERAL_boolean:
2569 		case LITERAL_byte:
2570 		case LITERAL_char:
2571 		case LITERAL_short:
2572 		case LITERAL_int:
2573 		case LITERAL_float:
2574 		case LITERAL_long:
2575 		case LITERAL_double:
2576 		{
2577 			typeSpec(false);
2578 			t2_AST = (AST)returnAST;
2579 			singleVariable(null,t2_AST);
2580 			v2_AST = (AST)returnAST;
2581 			if ( inputState.guessing==0 ) {
2582 				singleDeclarationNoInit_AST = (AST)currentAST.root;
2583 				singleDeclarationNoInit_AST = v2_AST;
2584 				currentAST.root = singleDeclarationNoInit_AST;
2585 				currentAST.child = singleDeclarationNoInit_AST!=null &&singleDeclarationNoInit_AST.getFirstChild()!=null ?
2586 					singleDeclarationNoInit_AST.getFirstChild() : singleDeclarationNoInit_AST;
2587 				currentAST.advanceChildToEnd();
2588 			}
2589 			break;
2590 		}
2591 		default:
2592 		{
2593 			throw new NoViableAltException(LT(1), getFilename());
2594 		}
2595 		}
2596 		returnAST = singleDeclarationNoInit_AST;
2597 	}
2598 	
2599 /** Used in cases where a declaration cannot have commas, or ends with the "in" operator instead of '='. */
2600 	public final void singleVariable(
2601 		AST mods, AST t
2602 	) throws RecognitionException, TokenStreamException {
2603 		
2604 		returnAST = null;
2605 		ASTPair currentAST = new ASTPair();
2606 		AST singleVariable_AST = null;
2607 		AST id_AST = null;
2608 		Token first = LT(1);
2609 		
2610 		variableName();
2611 		id_AST = (AST)returnAST;
2612 		if ( inputState.guessing==0 ) {
2613 			singleVariable_AST = (AST)currentAST.root;
2614 			singleVariable_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(VARIABLE_DEF,"VARIABLE_DEF",first,LT(1))).add(mods).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(t))).add(id_AST));
2615 			currentAST.root = singleVariable_AST;
2616 			currentAST.child = singleVariable_AST!=null &&singleVariable_AST.getFirstChild()!=null ?
2617 				singleVariable_AST.getFirstChild() : singleVariable_AST;
2618 			currentAST.advanceChildToEnd();
2619 		}
2620 		returnAST = singleVariable_AST;
2621 	}
2622 	
2623 /** A declaration with one declarator and optional initialization, like a parameterDeclaration.
2624  *  Used to parse declarations used for both binding and effect, in places like argument
2625  *  lists and <code>while</code> statements.
2626  */
2627 	public final void singleDeclaration() throws RecognitionException, TokenStreamException {
2628 		
2629 		returnAST = null;
2630 		ASTPair currentAST = new ASTPair();
2631 		AST singleDeclaration_AST = null;
2632 		AST sd_AST = null;
2633 		
2634 		singleDeclarationNoInit();
2635 		sd_AST = (AST)returnAST;
2636 		if ( inputState.guessing==0 ) {
2637 			singleDeclaration_AST = (AST)currentAST.root;
2638 			singleDeclaration_AST = sd_AST;
2639 			currentAST.root = singleDeclaration_AST;
2640 			currentAST.child = singleDeclaration_AST!=null &&singleDeclaration_AST.getFirstChild()!=null ?
2641 				singleDeclaration_AST.getFirstChild() : singleDeclaration_AST;
2642 			currentAST.advanceChildToEnd();
2643 		}
2644 		{
2645 		switch ( LA(1)) {
2646 		case ASSIGN:
2647 		{
2648 			varInitializer();
2649 			astFactory.addASTChild(currentAST, returnAST);
2650 			break;
2651 		}
2652 		case EOF:
2653 		case RBRACK:
2654 		case COMMA:
2655 		case RPAREN:
2656 		case SEMI:
2657 		{
2658 			break;
2659 		}
2660 		default:
2661 		{
2662 			throw new NoViableAltException(LT(1), getFilename());
2663 		}
2664 		}
2665 		}
2666 		singleDeclaration_AST = (AST)currentAST.root;
2667 		returnAST = singleDeclaration_AST;
2668 	}
2669 	
2670 /** An assignment operator '=' followed by an expression.  (Never empty.) */
2671 	public final void varInitializer() throws RecognitionException, TokenStreamException {
2672 		
2673 		returnAST = null;
2674 		ASTPair currentAST = new ASTPair();
2675 		AST varInitializer_AST = null;
2676 		
2677 		AST tmp41_AST = null;
2678 		tmp41_AST = astFactory.create(LT(1));
2679 		astFactory.makeASTRoot(currentAST, tmp41_AST);
2680 		match(ASSIGN);
2681 		nls();
2682 		expressionStatementNoCheck();
2683 		astFactory.addASTChild(currentAST, returnAST);
2684 		varInitializer_AST = (AST)currentAST.root;
2685 		returnAST = varInitializer_AST;
2686 	}
2687 	
2688 /** Used only as a lookahead predicate, before diving in and parsing a declaration.
2689  *  A declaration can be unambiguously introduced with "def", an annotation or a modifier token like "final".
2690  *  It may also be introduced by a simple identifier whose first character is an uppercase letter,
2691  *  as in {String x}.  A declaration can also be introduced with a built in type like 'int' or 'void'.
2692  *  Brackets (array and generic) are allowed, as in {List[] x} or {int[][] y}.
2693  *  Anything else is parsed as a statement of some sort (expression or command).
2694  *  <p>
2695  *  (In the absence of explicit method-call parens, we assume a capitalized name is a type name.
2696  *  Yes, this is a little hacky.  Alternatives are to complicate the declaration or command
2697  *  syntaxes, or to have the parser query the symbol table.  Parse-time queries are evil.
2698  *  And we want both {String x} and {println x}.  So we need a syntactic razor-edge to slip
2699  *  between 'println' and 'String'.)
2700  *
2701  *   *TODO* The declarationStart production needs to be strengthened to recognize
2702  *  things like {List<String> foo}.
2703  *  Right now it only knows how to skip square brackets after the type, not
2704  *  angle brackets.
2705  *  This probably turns out to be tricky because of >> vs. > >. If so,
2706  *  just put a TODO comment in.
2707  */
2708 previous bug bug overview next bug   	public final void declarationStart() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  ExcessiveMethodLength 
2709 		
2710 		returnAST = null;
2711 		ASTPair currentAST = new ASTPair();
2712 		AST declarationStart_AST = null;
2713 		
2714 		{
2715 		int _cnt29=0;
2716 		_loop29:
2717 		do {
2718 			switch ( LA(1)) {
2719 			case LITERAL_def:
2720 			{
2721 				{
2722 				match(LITERAL_def);
2723 				nls();
2724 				}
2725 				break;
2726 			}
2727 			case FINAL:
2728 			case ABSTRACT:
2729 			case STRICTFP:
2730 			case LITERAL_static:
2731 			case LITERAL_private:
2732 			case LITERAL_public:
2733 			case LITERAL_protected:
2734 			case LITERAL_transient:
2735 			case LITERAL_native:
2736 			case LITERAL_threadsafe:
2737 			case LITERAL_synchronized:
2738 			case LITERAL_volatile:
2739 			{
2740 				modifier();
2741 				nls();
2742 				break;
2743 			}
2744 			case AT:
2745 			{
2746 				annotation();
2747 				nls();
2748 				break;
2749 			}
2750 			default:
2751 				if ((_tokenSet_24.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
2752 					{
2753 					if ((LA(1)==IDENT) && (_tokenSet_34.member(LA(2)))) {
2754 						upperCaseIdent();
2755 					}
2756 					else if (((LA(1) >= LITERAL_void && LA(1) <= LITERAL_double))) {
2757 						builtInType();
2758 					}
2759 					else if ((LA(1)==IDENT) && (LA(2)==DOT)) {
2760 						qualifiedTypeName();
2761 					}
2762 					else {
2763 						throw new NoViableAltException(LT(1), getFilename());
2764 					}
2765 					
2766 					}
2767 					{
2768 					switch ( LA(1)) {
2769 					case LT:
2770 					{
2771 						typeArguments();
2772 						break;
2773 					}
2774 					case FINAL:
2775 					case ABSTRACT:
2776 					case STRICTFP:
2777 					case LITERAL_static:
2778 					case LITERAL_def:
2779 					case LBRACK:
2780 					case IDENT:
2781 					case STRING_LITERAL:
2782 					case AT:
2783 					case LITERAL_void:
2784 					case LITERAL_boolean:
2785 					case LITERAL_byte:
2786 					case LITERAL_char:
2787 					case LITERAL_short:
2788 					case LITERAL_int:
2789 					case LITERAL_float:
2790 					case LITERAL_long:
2791 					case LITERAL_double:
2792 					case LITERAL_private:
2793 					case LITERAL_public:
2794 					case LITERAL_protected:
2795 					case LITERAL_transient:
2796 					case LITERAL_native:
2797 					case LITERAL_threadsafe:
2798 					case LITERAL_synchronized:
2799 					case LITERAL_volatile:
2800 					{
2801 						break;
2802 					}
2803 					default:
2804 					{
2805 						throw new NoViableAltException(LT(1), getFilename());
2806 					}
2807 					}
2808 					}
2809 					{
2810 					_loop28:
2811 					do {
2812 						if ((LA(1)==LBRACK)) {
2813 							AST tmp43_AST = null;
2814 							tmp43_AST = astFactory.create(LT(1));
2815 							match(LBRACK);
2816 							balancedTokens();
2817 							AST tmp44_AST = null;
2818 							tmp44_AST = astFactory.create(LT(1));
2819 							match(RBRACK);
2820 						}
2821 						else {
2822 							break _loop28;
2823 						}
2824 						
2825 					} while (true);
2826 					}
2827 				}
2828 			else {
2829 				if ( _cnt29>=1 ) { break _loop29; } else {throw new NoViableAltException(LT(1), getFilename());}
2830 			}
2831 			}
2832 			_cnt29++;
2833 		} while (true);
2834 		}
2835 		{
2836 		switch ( LA(1)) {
2837 		case IDENT:
2838 		{
2839 			AST tmp45_AST = null;
2840 			tmp45_AST = astFactory.create(LT(1));
2841 			match(IDENT);
2842 			break;
2843 		}
2844 		case STRING_LITERAL:
2845 		{
2846 			AST tmp46_AST = null;
2847 			tmp46_AST = astFactory.create(LT(1));
2848 			match(STRING_LITERAL);
2849 			break;
2850 		}
2851 		default:
2852 		{
2853 			throw new NoViableAltException(LT(1), getFilename());
2854 		}
2855 		}
2856 		}
2857 		returnAST = declarationStart_AST;
2858 	}
2859 	
2860 previous bug bug overview next bug   	public final void modifier() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
2861 		
2862 		returnAST = null;
2863 		ASTPair currentAST = new ASTPair();
2864 		AST modifier_AST = null;
2865 		
2866 		switch ( LA(1)) {
2867 		case LITERAL_private:
2868 		{
2869 			AST tmp47_AST = null;
2870 			tmp47_AST = astFactory.create(LT(1));
2871 			astFactory.addASTChild(currentAST, tmp47_AST);
2872 			match(LITERAL_private);
2873 			modifier_AST = (AST)currentAST.root;
2874 			break;
2875 		}
2876 		case LITERAL_public:
2877 		{
2878 			AST tmp48_AST = null;
2879 			tmp48_AST = astFactory.create(LT(1));
2880 			astFactory.addASTChild(currentAST, tmp48_AST);
2881 			match(LITERAL_public);
2882 			modifier_AST = (AST)currentAST.root;
2883 			break;
2884 		}
2885 		case LITERAL_protected:
2886 		{
2887 			AST tmp49_AST = null;
2888 			tmp49_AST = astFactory.create(LT(1));
2889 			astFactory.addASTChild(currentAST, tmp49_AST);
2890 			match(LITERAL_protected);
2891 			modifier_AST = (AST)currentAST.root;
2892 			break;
2893 		}
2894 		case LITERAL_static:
2895 		{
2896 			AST tmp50_AST = null;
2897 			tmp50_AST = astFactory.create(LT(1));
2898 			astFactory.addASTChild(currentAST, tmp50_AST);
2899 			match(LITERAL_static);
2900 			modifier_AST = (AST)currentAST.root;
2901 			break;
2902 		}
2903 		case LITERAL_transient:
2904 		{
2905 			AST tmp51_AST = null;
2906 			tmp51_AST = astFactory.create(LT(1));
2907 			astFactory.addASTChild(currentAST, tmp51_AST);
2908 			match(LITERAL_transient);
2909 			modifier_AST = (AST)currentAST.root;
2910 			break;
2911 		}
2912 		case FINAL:
2913 		{
2914 			AST tmp52_AST = null;
2915 			tmp52_AST = astFactory.create(LT(1));
2916 			astFactory.addASTChild(currentAST, tmp52_AST);
2917 			match(FINAL);
2918 			modifier_AST = (AST)currentAST.root;
2919 			break;
2920 		}
2921 		case ABSTRACT:
2922 		{
2923 			AST tmp53_AST = null;
2924 			tmp53_AST = astFactory.create(LT(1));
2925 			astFactory.addASTChild(currentAST, tmp53_AST);
2926 			match(ABSTRACT);
2927 			modifier_AST = (AST)currentAST.root;
2928 			break;
2929 		}
2930 		case LITERAL_native:
2931 		{
2932 			AST tmp54_AST = null;
2933 			tmp54_AST = astFactory.create(LT(1));
2934 			astFactory.addASTChild(currentAST, tmp54_AST);
2935 			match(LITERAL_native);
2936 			modifier_AST = (AST)currentAST.root;
2937 			break;
2938 		}
2939 		case LITERAL_threadsafe:
2940 		{
2941 			AST tmp55_AST = null;
2942 			tmp55_AST = astFactory.create(LT(1));
2943 			astFactory.addASTChild(currentAST, tmp55_AST);
2944 			match(LITERAL_threadsafe);
2945 			modifier_AST = (AST)currentAST.root;
2946 			break;
2947 		}
2948 		case LITERAL_synchronized:
2949 		{
2950 			AST tmp56_AST = null;
2951 			tmp56_AST = astFactory.create(LT(1));
2952 			astFactory.addASTChild(currentAST, tmp56_AST);
2953 			match(LITERAL_synchronized);
2954 			modifier_AST = (AST)currentAST.root;
2955 			break;
2956 		}
2957 		case LITERAL_volatile:
2958 		{
2959 			AST tmp57_AST = null;
2960 			tmp57_AST = astFactory.create(LT(1));
2961 			astFactory.addASTChild(currentAST, tmp57_AST);
2962 			match(LITERAL_volatile);
2963 			modifier_AST = (AST)currentAST.root;
2964 			break;
2965 		}
2966 		case STRICTFP:
2967 		{
2968 			AST tmp58_AST = null;
2969 			tmp58_AST = astFactory.create(LT(1));
2970 			astFactory.addASTChild(currentAST, tmp58_AST);
2971 			match(STRICTFP);
2972 			modifier_AST = (AST)currentAST.root;
2973 			break;
2974 		}
2975 		default:
2976 		{
2977 			throw new NoViableAltException(LT(1), getFilename());
2978 		}
2979 		}
2980 		returnAST = modifier_AST;
2981 	}
2982 	
2983 previous bug bug overview next bug   	public final void annotation() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc  ExcessiveMethodLength 
2984 		
2985 		returnAST = null;
2986 		ASTPair currentAST = new ASTPair();
2987 		AST annotation_AST = null;
2988 		AST i_AST = null;
2989 		AST args_AST = null;
2990 		Token first = LT(1);
2991 		
2992 		match(AT);
2993 		identifier();
2994 		i_AST = (AST)returnAST;
2995 		nls();
2996 		{
2997 		if ((LA(1)==LPAREN) && (_tokenSet_35.member(LA(2)))) {
2998 			match(LPAREN);
2999 			{
3000 			switch ( LA(1)) {
3001 			case FINAL:
3002 			case ABSTRACT:
3003 			case UNUSED_GOTO:
3004 			case UNUSED_CONST:
3005 			case UNUSED_DO:
3006 			case STRICTFP:
3007 			case LITERAL_package:
3008 			case LITERAL_import:
3009 			case LITERAL_static:
3010 			case LITERAL_def:
3011 			case LBRACK:
3012 			case IDENT:
3013 			case STRING_LITERAL:
3014 			case LPAREN:
3015 			case LITERAL_class:
3016 			case LITERAL_interface:
3017 			case LITERAL_enum:
3018 			case AT:
3019 			case LITERAL_extends:
3020 			case LITERAL_super:
3021 			case LITERAL_void:
3022 			case LITERAL_boolean:
3023 			case LITERAL_byte:
3024 			case LITERAL_char:
3025 			case LITERAL_short:
3026 			case LITERAL_int:
3027 			case LITERAL_float:
3028 			case LITERAL_long:
3029 			case LITERAL_double:
3030 			case LITERAL_as:
3031 			case LITERAL_private:
3032 			case LITERAL_public:
3033 			case LITERAL_protected:
3034 			case LITERAL_transient:
3035 			case LITERAL_native:
3036 			case LITERAL_threadsafe:
3037 			case LITERAL_synchronized:
3038 			case LITERAL_volatile:
3039 			case LCURLY:
3040 			case LITERAL_default:
3041 			case LITERAL_throws:
3042 			case LITERAL_implements:
3043 			case LITERAL_this:
3044 			case LITERAL_if:
3045 			case LITERAL_else:
3046 			case LITERAL_while:
3047 			case LITERAL_switch:
3048 			case LITERAL_for:
3049 			case LITERAL_in:
3050 			case LITERAL_return:
3051 			case LITERAL_break:
3052 			case LITERAL_continue:
3053 			case LITERAL_throw:
3054 			case LITERAL_assert:
3055 			case PLUS:
3056 			case MINUS:
3057 			case LITERAL_case:
3058 			case LITERAL_try:
3059 			case LITERAL_finally:
3060 			case LITERAL_catch:
3061 			case LITERAL_false:
3062 			case LITERAL_instanceof:
3063 			case LITERAL_new:
3064 			case LITERAL_null:
3065 			case LITERAL_true:
3066 			case INC:
3067 			case DEC:
3068 			case BNOT:
3069 			case LNOT:
3070 			case STRING_CTOR_START:
3071 			case NUM_INT:
3072 			case NUM_FLOAT:
3073 			case NUM_LONG:
3074 			case NUM_DOUBLE:
3075 			case NUM_BIG_INT:
3076 			case NUM_BIG_DECIMAL:
3077 			{
3078 				annotationArguments();
3079 				args_AST = (AST)returnAST;
3080 				break;
3081 			}
3082 			case RPAREN:
3083 			{
3084 				break;
3085 			}
3086 			default:
3087 			{
3088 				throw new NoViableAltException(LT(1), getFilename());
3089 			}
3090 			}
3091 			}
3092 			match(RPAREN);
3093 		}
3094 previous bug bug overview next bug   		else if ((_tokenSet_36.member(LA(1))) && (_tokenSet_37.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
3095 		}
3096 		else {
3097 			throw new NoViableAltException(LT(1), getFilename());
3098 		}
3099 		
3100 		}
3101 		if ( inputState.guessing==0 ) {
3102 			annotation_AST = (AST)currentAST.root;
3103 			annotation_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(ANNOTATION,"ANNOTATION",first,LT(1))).add(i_AST).add(args_AST));
3104 			currentAST.root = annotation_AST;
3105 			currentAST.child = annotation_AST!=null &&annotation_AST.getFirstChild()!=null ?
3106 				annotation_AST.getFirstChild() : annotation_AST;
3107 			currentAST.advanceChildToEnd();
3108 		}
3109 		returnAST = annotation_AST;
3110 	}
3111 	
3112 /** An IDENT token whose spelling is required to start with an uppercase letter.
3113  *  In the case of a simple statement {UpperID name} the identifier is taken to be a type name, not a command name.
3114  */
3115 	public final void upperCaseIdent() throws RecognitionException, TokenStreamException {
3116 		
3117 		returnAST = null;
3118 		ASTPair currentAST = new ASTPair();
3119 		AST upperCaseIdent_AST = null;
3120 		
3121 		if (!(isUpperCase(LT(1))))
3122 		  throw new SemanticException("isUpperCase(LT(1))");
3123 		AST tmp62_AST = null;
3124 		tmp62_AST = astFactory.create(LT(1));
3125 		astFactory.addASTChild(currentAST, tmp62_AST);
3126 		match(IDENT);
3127 		upperCaseIdent_AST = (AST)currentAST.root;
3128 		returnAST = upperCaseIdent_AST;
3129 	}
3130 	
3131 previous bug bug overview next bug   	public final void builtInType() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
3132 		
3133 		returnAST = null;
3134 		ASTPair currentAST = new ASTPair();
3135 		AST builtInType_AST = null;
3136 		
3137 		switch ( LA(1)) {
3138 		case LITERAL_void:
3139 		{
3140 			AST tmp63_AST = null;
3141 			tmp63_AST = astFactory.create(LT(1));
3142 			astFactory.addASTChild(currentAST, tmp63_AST);
3143 			match(LITERAL_void);
3144 			builtInType_AST = (AST)currentAST.root;
3145 			break;
3146 		}
3147 		case LITERAL_boolean:
3148 		{
3149 			AST tmp64_AST = null;
3150 			tmp64_AST = astFactory.create(LT(1));
3151 			astFactory.addASTChild(currentAST, tmp64_AST);
3152 			match(LITERAL_boolean);
3153 			builtInType_AST = (AST)currentAST.root;
3154 			break;
3155 		}
3156 		case LITERAL_byte:
3157 		{
3158 			AST tmp65_AST = null;
3159 			tmp65_AST = astFactory.create(LT(1));
3160 			astFactory.addASTChild(currentAST, tmp65_AST);
3161 			match(LITERAL_byte);
3162 			builtInType_AST = (AST)currentAST.root;
3163 			break;
3164 		}
3165 		case LITERAL_char:
3166 		{
3167 			AST tmp66_AST = null;
3168 			tmp66_AST = astFactory.create(LT(1));
3169 			astFactory.addASTChild(currentAST, tmp66_AST);
3170 			match(LITERAL_char);
3171 			builtInType_AST = (AST)currentAST.root;
3172 			break;
3173 		}
3174 		case LITERAL_short:
3175 		{
3176 			AST tmp67_AST = null;
3177 			tmp67_AST = astFactory.create(LT(1));
3178 			astFactory.addASTChild(currentAST, tmp67_AST);
3179 			match(LITERAL_short);
3180 			builtInType_AST = (AST)currentAST.root;
3181 			break;
3182 		}
3183 		case LITERAL_int:
3184 		{
3185 			AST tmp68_AST = null;
3186 			tmp68_AST = astFactory.create(LT(1));
3187 			astFactory.addASTChild(currentAST, tmp68_AST);
3188 			match(LITERAL_int);
3189 			builtInType_AST = (AST)currentAST.root;
3190 			break;
3191 		}
3192 		case LITERAL_float:
3193 		{
3194 			AST tmp69_AST = null;
3195 			tmp69_AST = astFactory.create(LT(1));
3196 			astFactory.addASTChild(currentAST, tmp69_AST);
3197 			match(LITERAL_float);
3198 			builtInType_AST = (AST)currentAST.root;
3199 			break;
3200 		}
3201 		case LITERAL_long:
3202 		{
3203 			AST tmp70_AST = null;
3204 			tmp70_AST = astFactory.create(LT(1));
3205 			astFactory.addASTChild(currentAST, tmp70_AST);
3206 			match(LITERAL_long);
3207 			builtInType_AST = (AST)currentAST.root;
3208 			break;
3209 		}
3210 		case LITERAL_double:
3211 		{
3212 			AST tmp71_AST = null;
3213 			tmp71_AST = astFactory.create(LT(1));
3214 			astFactory.addASTChild(currentAST, tmp71_AST);
3215 			match(LITERAL_double);
3216 			builtInType_AST = (AST)currentAST.root;
3217 			break;
3218 		}
3219 		default:
3220 		{
3221 			throw new NoViableAltException(LT(1), getFilename());
3222 		}
3223 		}
3224 		returnAST = builtInType_AST;
3225 	}
3226 	
3227 	public final void qualifiedTypeName() throws RecognitionException, TokenStreamException {
3228 		
3229 		returnAST = null;
3230 		ASTPair currentAST = new ASTPair();
3231 		AST qualifiedTypeName_AST = null;
3232 		
3233 		AST tmp72_AST = null;
3234 		tmp72_AST = astFactory.create(LT(1));
3235 		match(IDENT);
3236 		AST tmp73_AST = null;
3237 		tmp73_AST = astFactory.create(LT(1));
3238 		match(DOT);
3239 		{
3240 		_loop36:
3241 		do {
3242 			if ((LA(1)==IDENT) && (LA(2)==DOT)) {
3243 				AST tmp74_AST = null;
3244 				tmp74_AST = astFactory.create(LT(1));
3245 				match(IDENT);
3246 				AST tmp75_AST = null;
3247 				tmp75_AST = astFactory.create(LT(1));
3248 				match(DOT);
3249 			}
3250 			else {
3251 				break _loop36;
3252 			}
3253 			
3254 		} while (true);
3255 		}
3256 		upperCaseIdent();
3257 		returnAST = qualifiedTypeName_AST;
3258 	}
3259 	
3260 previous bug bug overview next bug   	public final void typeArguments() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
3261 		
3262 		returnAST = null;
3263 		ASTPair currentAST = new ASTPair();
3264 		AST typeArguments_AST = null;
3265 		Token first = LT(1);
3266 		int currentLtLevel = 0;
3267 		
3268 		if ( inputState.guessing==0 ) {
3269 			currentLtLevel = ltCounter;
3270 		}
3271 		match(LT);
3272 		if ( inputState.guessing==0 ) {
3273 			ltCounter++;
3274 		}
3275 		nls();
3276 		typeArgument();
3277 		astFactory.addASTChild(currentAST, returnAST);
3278 		{
3279 		_loop58:
3280 		do {
3281 			if (((LA(1)==COMMA) && (_tokenSet_38.member(LA(2))))&&(inputState.guessing !=0 || ltCounter == currentLtLevel + 1)) {
3282 				match(COMMA);
3283 				nls();
3284 				typeArgument();
3285 				astFactory.addASTChild(currentAST, returnAST);
3286 			}
3287 			else {
3288 				break _loop58;
3289 			}
3290 			
3291 		} while (true);
3292 		}
3293 		nls();
3294 		{
3295 		if ((_tokenSet_39.member(LA(1))) && (_tokenSet_40.member(LA(2)))) {
3296 			typeArgumentsOrParametersEnd();
3297 			astFactory.addASTChild(currentAST, returnAST);
3298 		}
3299 previous bug bug overview next bug   		else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_3.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
3300 		}
3301 		else {
3302 			throw new NoViableAltException(LT(1), getFilename());
3303 		}
3304 		
3305 		}
3306 		if (!(matchGenericTypeBrackets(((currentLtLevel != 0) || ltCounter == currentLtLevel),
3307         "Missing closing bracket '>' for generics types", "Please specify the missing bracket!")))
3308 		  throw new SemanticException("matchGenericTypeBrackets(((currentLtLevel != 0) || ltCounter == currentLtLevel),\n        \"Missing closing bracket '>' for generics types\", \"Please specify the missing bracket!\")");
3309 		if ( inputState.guessing==0 ) {
3310 			typeArguments_AST = (AST)currentAST.root;
3311 			typeArguments_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS",first,LT(1))).add(typeArguments_AST));
3312 			currentAST.root = typeArguments_AST;
3313 			currentAST.child = typeArguments_AST!=null &&typeArguments_AST.getFirstChild()!=null ?
3314 				typeArguments_AST.getFirstChild() : typeArguments_AST;
3315 			currentAST.advanceChildToEnd();
3316 		}
3317 		typeArguments_AST = (AST)currentAST.root;
3318 		returnAST = typeArguments_AST;
3319 	}
3320 	
3321 	public final void balancedTokens() throws RecognitionException, TokenStreamException {
3322 		
3323 		returnAST = null;
3324 		ASTPair currentAST = new ASTPair();
3325 		AST balancedTokens_AST = null;
3326 		
3327 		{
3328 		_loop570:
3329 		do {
3330 			if ((_tokenSet_41.member(LA(1)))) {
3331 				balancedBrackets();
3332 			}
3333 			else if ((_tokenSet_42.member(LA(1)))) {
3334 				{
3335 				match(_tokenSet_42);
3336 				}
3337 			}
3338 			else {
3339 				break _loop570;
3340 			}
3341 			
3342 		} while (true);
3343 		}
3344 		returnAST = balancedTokens_AST;
3345 	}
3346 	
3347 /**
3348  * lookahead predicate for usage of generics in methods
3349  * as parameter for the method. Example:
3350  * static <T> T foo(){}
3351  * <T> must be first after the modifier.
3352  * This rule allows more and does no exact match, but it
3353  * is only a lookahead, not the real rule.
3354  */
3355 	public final void genericMethodStart() throws RecognitionException, TokenStreamException {
3356 		
3357 		returnAST = null;
3358 		ASTPair currentAST = new ASTPair();
3359 		AST genericMethodStart_AST = null;
3360 		
3361 		{
3362 		int _cnt33=0;
3363 		_loop33:
3364 		do {
3365 			switch ( LA(1)) {
3366 			case LITERAL_def:
3367 			{
3368 				match(LITERAL_def);
3369 				nls();
3370 				break;
3371 			}
3372 			case FINAL:
3373 			case ABSTRACT:
3374 			case STRICTFP:
3375 			case LITERAL_static:
3376 			case LITERAL_private:
3377 			case LITERAL_public:
3378 			case LITERAL_protected:
3379 			case LITERAL_transient:
3380 			case LITERAL_native:
3381 			case LITERAL_threadsafe:
3382 			case LITERAL_synchronized:
3383 			case LITERAL_volatile:
3384 			{
3385 				modifier();
3386 				nls();
3387 				break;
3388 			}
3389 			case AT:
3390 			{
3391 				annotation();
3392 				nls();
3393 				break;
3394 			}
3395 			default:
3396 			{
3397 				if ( _cnt33>=1 ) { break _loop33; } else {throw new NoViableAltException(LT(1), getFilename());}
3398 			}
3399 			}
3400 			_cnt33++;
3401 		} while (true);
3402 		}
3403 		AST tmp80_AST = null;
3404 		tmp80_AST = astFactory.create(LT(1));
3405 		match(LT);
3406 		returnAST = genericMethodStart_AST;
3407 	}
3408 	
3409 /** Used to look ahead for a constructor
3410  */
3411 	public final void constructorStart() throws RecognitionException, TokenStreamException {
3412 		
3413 		returnAST = null;
3414 		ASTPair currentAST = new ASTPair();
3415 		AST constructorStart_AST = null;
3416 		Token  id = null;
3417 		AST id_AST = null;
3418 		
3419 		modifiersOpt();
3420 		id = LT(1);
3421 		id_AST = astFactory.create(id);
3422 		match(IDENT);
3423 		if (!(isConstructorIdent(id)))
3424 		  throw new SemanticException("isConstructorIdent(id)");
3425 		nls();
3426 		match(LPAREN);
3427 		returnAST = constructorStart_AST;
3428 	}
3429 	
3430 /** A list of zero or more modifiers, annotations, or "def". */
3431 	public final void modifiersOpt() throws RecognitionException, TokenStreamException {
3432 		
3433 		returnAST = null;
3434 		ASTPair currentAST = new ASTPair();
3435 		AST modifiersOpt_AST = null;
3436 		Token first = LT(1);
3437 		
3438 		{
3439 		if ((_tokenSet_12.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
3440 			modifiersInternal();
3441 			astFactory.addASTChild(currentAST, returnAST);
3442 		}
3443 previous bug bug overview next bug   		else if ((_tokenSet_44.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
3444 		}
3445 		else {
3446 			throw new NoViableAltException(LT(1), getFilename());
3447 		}
3448 		
3449 		}
3450 		if ( inputState.guessing==0 ) {
3451 			modifiersOpt_AST = (AST)currentAST.root;
3452 			modifiersOpt_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(MODIFIERS,"MODIFIERS",first,LT(1))).add(modifiersOpt_AST));
3453 			currentAST.root = modifiersOpt_AST;
3454 			currentAST.child = modifiersOpt_AST!=null &&modifiersOpt_AST.getFirstChild()!=null ?
3455 				modifiersOpt_AST.getFirstChild() : modifiersOpt_AST;
3456 			currentAST.advanceChildToEnd();
3457 		}
3458 		modifiersOpt_AST = (AST)currentAST.root;
3459 		returnAST = modifiersOpt_AST;
3460 	}
3461 	
3462 /** Used only as a lookahead predicate for nested type declarations. */
3463 	public final void typeDeclarationStart() throws RecognitionException, TokenStreamException {
3464 		
3465 		returnAST = null;
3466 		ASTPair currentAST = new ASTPair();
3467 		AST typeDeclarationStart_AST = null;
3468 		
3469 		modifiersOpt();
3470 		{
3471 		switch ( LA(1)) {
3472 		case LITERAL_class:
3473 		{
3474 			match(LITERAL_class);
3475 			break;
3476 		}
3477 		case LITERAL_interface:
3478 		{
3479 			match(LITERAL_interface);
3480 			break;
3481 		}
3482 		case LITERAL_enum:
3483 		{
3484 			match(LITERAL_enum);
3485 			break;
3486 		}
3487 		case AT:
3488 		{
3489 			AST tmp85_AST = null;
3490 			tmp85_AST = astFactory.create(LT(1));
3491 			match(AT);
3492 			match(LITERAL_interface);
3493 			break;
3494 		}
3495 		default:
3496 		{
3497 			throw new NoViableAltException(LT(1), getFilename());
3498 		}
3499 		}
3500 		}
3501 		returnAST = typeDeclarationStart_AST;
3502 	}
3503 	
3504 	public final void classTypeSpec(
3505 		boolean addImagNode
3506 	) throws RecognitionException, TokenStreamException {
3507 		
3508 		returnAST = null;
3509 		ASTPair currentAST = new ASTPair();
3510 		AST classTypeSpec_AST = null;
3511 		AST ct_AST = null;
3512 		Token first = LT(1);
3513 		
3514 		classOrInterfaceType(false);
3515 		ct_AST = (AST)returnAST;
3516 		declaratorBrackets(ct_AST);
3517 		astFactory.addASTChild(currentAST, returnAST);
3518 		if ( inputState.guessing==0 ) {
3519 			classTypeSpec_AST = (AST)currentAST.root;
3520 			
3521 			if ( addImagNode ) {
3522 			classTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(classTypeSpec_AST));
3523 			}
3524 			
3525 			currentAST.root = classTypeSpec_AST;
3526 			currentAST.child = classTypeSpec_AST!=null &&classTypeSpec_AST.getFirstChild()!=null ?
3527 				classTypeSpec_AST.getFirstChild() : classTypeSpec_AST;
3528 			currentAST.advanceChildToEnd();
3529 		}
3530 		classTypeSpec_AST = (AST)currentAST.root;
3531 		returnAST = classTypeSpec_AST;
3532 	}
3533 	
3534 	public final void builtInTypeSpec(
3535 		boolean addImagNode
3536 	) throws RecognitionException, TokenStreamException {
3537 		
3538 		returnAST = null;
3539 		ASTPair currentAST = new ASTPair();
3540 		AST builtInTypeSpec_AST = null;
3541 		AST bt_AST = null;
3542 		Token first = LT(1);
3543 		
3544 		builtInType();
3545 		bt_AST = (AST)returnAST;
3546 		declaratorBrackets(bt_AST);
3547 		astFactory.addASTChild(currentAST, returnAST);
3548 		if ( inputState.guessing==0 ) {
3549 			builtInTypeSpec_AST = (AST)currentAST.root;
3550 			
3551 			if ( addImagNode ) {
3552 			builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(builtInTypeSpec_AST));
3553 			}
3554 			
3555 			currentAST.root = builtInTypeSpec_AST;
3556 			currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ?
3557 				builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST;
3558 			currentAST.advanceChildToEnd();
3559 		}
3560 		builtInTypeSpec_AST = (AST)currentAST.root;
3561 		returnAST = builtInTypeSpec_AST;
3562 	}
3563 	
3564 previous bug bug overview next bug   	public final void classOrInterfaceType(  HEALTH4J >>  :  health.MissingJavaDoc  ExcessiveMethodLength 
3565 		boolean addImagNode
3566 	) throws RecognitionException, TokenStreamException {
3567 		
3568 		returnAST = null;
3569 		ASTPair currentAST = new ASTPair();
3570 		AST classOrInterfaceType_AST = null;
3571 		Token  i1 = null;
3572 		AST i1_AST = null;
3573 		Token  d = null;
3574 		AST d_AST = null;
3575 		Token  i2 = null;
3576 		AST i2_AST = null;
3577 		AST ta_AST = null;
3578 		Token first = LT(1);
3579 		
3580 		i1 = LT(1);
3581 		i1_AST = astFactory.create(i1);
3582 		astFactory.makeASTRoot(currentAST, i1_AST);
3583 		match(IDENT);
3584 		{
3585 		if ((LA(1)==LT) && (_tokenSet_38.member(LA(2)))) {
3586 			typeArguments();
3587 			astFactory.addASTChild(currentAST, returnAST);
3588 		}
3589 		else if ((LA(1)==LT) && (LA(2)==GT)) {
3590 			typeArgumentsDiamond();
3591 			astFactory.addASTChild(currentAST, returnAST);
3592 		}
3593 previous bug bug overview next bug   		else if ((_tokenSet_40.member(LA(1)))) {  HEALTH4J >>  :  EmptyIfStmt 
3594 		}
3595 		else {
3596 			throw new NoViableAltException(LT(1), getFilename());
3597 		}
3598 		
3599 		}
3600 		{
3601 		_loop47:
3602 		do {
3603 			if ((LA(1)==DOT) && (LA(2)==IDENT)) {
3604 				d = LT(1);
3605 				d_AST = astFactory.create(d);
3606 				match(DOT);
3607 				i2 = LT(1);
3608 				i2_AST = astFactory.create(i2);
3609 				match(IDENT);
3610 				{
3611 				switch ( LA(1)) {
3612 				case LT:
3613 				{
3614 					typeArguments();
3615 					ta_AST = (AST)returnAST;
3616 					break;
3617 				}
3618 				case EOF:
3619 				case FINAL:
3620 				case ABSTRACT:
3621 				case UNUSED_GOTO:
3622 				case UNUSED_CONST:
3623 				case UNUSED_DO:
3624 				case STRICTFP:
3625 				case LITERAL_package:
3626 				case LITERAL_import:
3627 				case LITERAL_static:
3628 				case LITERAL_def:
3629 				case LBRACK:
3630 				case RBRACK:
3631 				case IDENT:
3632 				case STRING_LITERAL:
3633 				case DOT:
3634 				case LPAREN:
3635 				case LITERAL_class:
3636 				case LITERAL_interface:
3637 				case LITERAL_enum:
3638 				case AT:
3639 				case QUESTION:
3640 				case LITERAL_extends:
3641 				case LITERAL_super:
3642 				case GT:
3643 				case COMMA:
3644 				case SR:
3645 				case BSR:
3646 				case LITERAL_void:
3647 				case LITERAL_boolean:
3648 				case LITERAL_byte:
3649 				case LITERAL_char:
3650 				case LITERAL_short:
3651 				case LITERAL_int:
3652 				case LITERAL_float:
3653 				case LITERAL_long:
3654 				case LITERAL_double:
3655 				case LITERAL_as:
3656 				case LITERAL_private:
3657 				case LITERAL_public:
3658 				case LITERAL_protected:
3659 				case LITERAL_transient:
3660 				case LITERAL_native:
3661 				case LITERAL_threadsafe:
3662 				case LITERAL_synchronized:
3663 				case LITERAL_volatile:
3664 				case RPAREN:
3665 				case ASSIGN:
3666 				case BAND:
3667 				case LCURLY:
3668 				case RCURLY:
3669 				case SEMI:
3670 				case LITERAL_default:
3671 				case LITERAL_throws:
3672 				case LITERAL_implements:
3673 				case LITERAL_this:
3674 				case TRIPLE_DOT:
3675 				case BOR:
3676 				case CLOSABLE_BLOCK_OP:
3677 				case COLON:
3678 				case LITERAL_if:
3679 				case LITERAL_else:
3680 				case LITERAL_while:
3681 				case LITERAL_switch:
3682 				case LITERAL_for:
3683 				case LITERAL_in:
3684 				case LITERAL_return:
3685 				case LITERAL_break:
3686 				case LITERAL_continue:
3687 				case LITERAL_throw:
3688 				case LITERAL_assert:
3689 				case PLUS:
3690 				case MINUS:
3691 				case LITERAL_case:
3692 				case LITERAL_try:
3693 				case LITERAL_finally:
3694 				case LITERAL_catch:
3695 				case LITERAL_false:
3696 				case LITERAL_instanceof:
3697 				case LITERAL_new:
3698 				case LITERAL_null:
3699 				case LITERAL_true:
3700 				case PLUS_ASSIGN:
3701 				case MINUS_ASSIGN:
3702 				case STAR_ASSIGN:
3703 				case DIV_ASSIGN:
3704 				case MOD_ASSIGN:
3705 				case SR_ASSIGN:
3706 				case BSR_ASSIGN:
3707 				case SL_ASSIGN:
3708 				case BAND_ASSIGN:
3709 				case BXOR_ASSIGN:
3710 				case BOR_ASSIGN:
3711 				case STAR_STAR_ASSIGN:
3712 				case ELVIS_OPERATOR:
3713 				case LOR:
3714 				case LAND:
3715 				case BXOR:
3716 				case REGEX_FIND:
3717 				case REGEX_MATCH:
3718 				case NOT_EQUAL:
3719 				case EQUAL:
3720 				case IDENTICAL:
3721 				case NOT_IDENTICAL:
3722 				case COMPARE_TO:
3723 				case INC:
3724 				case DEC:
3725 				case BNOT:
3726 				case LNOT:
3727 				case STRING_CTOR_START:
3728 				case NUM_INT:
3729 				case NUM_FLOAT:
3730 				case NUM_LONG:
3731 				case NUM_DOUBLE:
3732 				case NUM_BIG_INT:
3733 				case NUM_BIG_DECIMAL:
3734 				case NLS:
3735 				{
3736 					break;
3737 				}
3738 				default:
3739 				{
3740 					throw new NoViableAltException(LT(1), getFilename());
3741 				}
3742 				}
3743 				}
3744 				if ( inputState.guessing==0 ) {
3745 					i1_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(DOT,".",first,LT(1))).add(i1_AST).add(i2_AST).add(ta_AST));
3746 				}
3747 			}
3748 			else {
3749 				break _loop47;
3750 			}
3751 			
3752 		} while (true);
3753 		}
3754 		if ( inputState.guessing==0 ) {
3755 			classOrInterfaceType_AST = (AST)currentAST.root;
3756 			
3757 			classOrInterfaceType_AST = i1_AST;
3758 			if ( addImagNode ) {
3759 			classOrInterfaceType_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(classOrInterfaceType_AST));
3760 			}
3761 			
3762 			currentAST.root = classOrInterfaceType_AST;
3763 			currentAST.child = classOrInterfaceType_AST!=null &&classOrInterfaceType_AST.getFirstChild()!=null ?
3764 				classOrInterfaceType_AST.getFirstChild() : classOrInterfaceType_AST;
3765 			currentAST.advanceChildToEnd();
3766 		}
3767 		classOrInterfaceType_AST = (AST)currentAST.root;
3768 		returnAST = classOrInterfaceType_AST;
3769 	}
3770 	
3771 /** After some type names, where zero or more empty bracket pairs are allowed.
3772  *  We use ARRAY_DECLARATOR to represent this.
3773  *  TODO:  Is there some more Groovy way to view this in terms of the indexed property syntax?
3774  */
3775 	public final void declaratorBrackets(
3776 		AST typ
3777 	) throws RecognitionException, TokenStreamException {
3778 		
3779 		returnAST = null;
3780 		ASTPair currentAST = new ASTPair();
3781 		AST declaratorBrackets_AST = null;
3782 		
3783 		if ( inputState.guessing==0 ) {
3784 			declaratorBrackets_AST = (AST)currentAST.root;
3785 			declaratorBrackets_AST=typ;
3786 			currentAST.root = declaratorBrackets_AST;
3787 			currentAST.child = declaratorBrackets_AST!=null &&declaratorBrackets_AST.getFirstChild()!=null ?
3788 				declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST;
3789 			currentAST.advanceChildToEnd();
3790 		}
3791 		{
3792 		_loop248:
3793 		do {
3794 			if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
3795 				match(LBRACK);
3796 				match(RBRACK);
3797 				if ( inputState.guessing==0 ) {
3798 					declaratorBrackets_AST = (AST)currentAST.root;
3799 					declaratorBrackets_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(ARRAY_DECLARATOR,"[",typ,LT(1))).add(declaratorBrackets_AST));
3800 					currentAST.root = declaratorBrackets_AST;
3801 					currentAST.child = declaratorBrackets_AST!=null &&declaratorBrackets_AST.getFirstChild()!=null ?
3802 						declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST;
3803 					currentAST.advanceChildToEnd();
3804 				}
3805 			}
3806 			else {
3807 				break _loop248;
3808 			}
3809 			
3810 		} while (true);
3811 		}
3812 		declaratorBrackets_AST = (AST)currentAST.root;
3813 		returnAST = declaratorBrackets_AST;
3814 	}
3815 	
3816 	public final void typeArgumentsDiamond() throws RecognitionException, TokenStreamException {
3817 		
3818 		returnAST = null;
3819 		ASTPair currentAST = new ASTPair();
3820 		AST typeArgumentsDiamond_AST = null;
3821 		Token first = LT(1);
3822 		
3823 		match(LT);
3824 		match(GT);
3825 		nls();
3826 		typeArgumentsDiamond_AST = (AST)currentAST.root;
3827 		returnAST = typeArgumentsDiamond_AST;
3828 	}
3829 	
3830 	public final void typeArgumentSpec() throws RecognitionException, TokenStreamException {
3831 		
3832 		returnAST = null;
3833 		ASTPair currentAST = new ASTPair();
3834 		AST typeArgumentSpec_AST = null;
3835 		
3836 		switch ( LA(1)) {
3837 		case IDENT:
3838 		{
3839 			classTypeSpec(true);
3840 			astFactory.addASTChild(currentAST, returnAST);
3841 			typeArgumentSpec_AST = (AST)currentAST.root;
3842 			break;
3843 		}
3844 		case LITERAL_void:
3845 		case LITERAL_boolean:
3846 		case LITERAL_byte:
3847 		case LITERAL_char:
3848 		case LITERAL_short:
3849 		case LITERAL_int:
3850 		case LITERAL_float:
3851 		case LITERAL_long:
3852 		case LITERAL_double:
3853 		{
3854 			builtInTypeArraySpec(true);
3855 			astFactory.addASTChild(currentAST, returnAST);
3856 			typeArgumentSpec_AST = (AST)currentAST.root;
3857 			break;
3858 		}
3859 		default:
3860 		{
3861 			throw new NoViableAltException(LT(1), getFilename());
3862 		}
3863 		}
3864 		returnAST = typeArgumentSpec_AST;
3865 	}
3866 	
3867 previous bug bug overview next bug   	public final void builtInTypeArraySpec(  HEALTH4J >>  :  health.MissingJavaDoc 
3868 		boolean addImagNode
3869 	) throws RecognitionException, TokenStreamException {
3870 		
3871 		returnAST = null;
3872 		ASTPair currentAST = new ASTPair();
3873 		AST builtInTypeArraySpec_AST = null;
3874 		AST bt_AST = null;
3875 		Token first = LT(1);
3876 		
3877 		builtInType();
3878 		bt_AST = (AST)returnAST;
3879 		{
3880 		boolean synPredMatched66 = false;
3881 		if (((_tokenSet_40.member(LA(1))) && (_tokenSet_3.member(LA(2))))) {
3882 			int _m66 = mark();
3883 			synPredMatched66 = true;
3884 			inputState.guessing++;
3885 			try {
3886 				{
3887 				match(LBRACK);
3888 				}
3889 			}
3890 			catch (RecognitionException pe) {
3891 				synPredMatched66 = false;
3892 			}
3893 			rewind(_m66);
3894 inputState.guessing--;
3895 		}
3896 		if ( synPredMatched66 ) {
3897 			declaratorBrackets(bt_AST);
3898 			astFactory.addASTChild(currentAST, returnAST);
3899 		}
3900 		else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_3.member(LA(2)))) {
3901 			if ( inputState.guessing==0 ) {
3902 				require(false,
3903 				"primitive type parameters not allowed here",
3904 				"use the corresponding wrapper type, such as Integer for int"
3905 				);
3906 			}
3907 		}
3908 		else {
3909 			throw new NoViableAltException(LT(1), getFilename());
3910 		}
3911 		
3912 		}
3913 		if ( inputState.guessing==0 ) {
3914 			builtInTypeArraySpec_AST = (AST)currentAST.root;
3915 			
3916 			if ( addImagNode ) {
3917 			builtInTypeArraySpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(builtInTypeArraySpec_AST));
3918 			}
3919 			
3920 			currentAST.root = builtInTypeArraySpec_AST;
3921 			currentAST.child = builtInTypeArraySpec_AST!=null &&builtInTypeArraySpec_AST.getFirstChild()!=null ?
3922 				builtInTypeArraySpec_AST.getFirstChild() : builtInTypeArraySpec_AST;
3923 			currentAST.advanceChildToEnd();
3924 		}
3925 		builtInTypeArraySpec_AST = (AST)currentAST.root;
3926 		returnAST = builtInTypeArraySpec_AST;
3927 	}
3928 	
3929 	public final void typeArgument() throws RecognitionException, TokenStreamException {
3930 		
3931 		returnAST = null;
3932 		ASTPair currentAST = new ASTPair();
3933 		AST typeArgument_AST = null;
3934 		Token first = LT(1);
3935 		
3936 		{
3937 		switch ( LA(1)) {
3938 		case IDENT:
3939 		case LITERAL_void:
3940 		case LITERAL_boolean:
3941 		case LITERAL_byte:
3942 		case LITERAL_char:
3943 		case LITERAL_short:
3944 		case LITERAL_int:
3945 		case LITERAL_float:
3946 		case LITERAL_long:
3947 		case LITERAL_double:
3948 		{
3949 			typeArgumentSpec();
3950 			astFactory.addASTChild(currentAST, returnAST);
3951 			break;
3952 		}
3953 		case QUESTION:
3954 		{
3955 			wildcardType();
3956 			astFactory.addASTChild(currentAST, returnAST);
3957 			break;
3958 		}
3959 		default:
3960 		{
3961 			throw new NoViableAltException(LT(1), getFilename());
3962 		}
3963 		}
3964 		}
3965 		if ( inputState.guessing==0 ) {
3966 			typeArgument_AST = (AST)currentAST.root;
3967 			typeArgument_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_ARGUMENT,"TYPE_ARGUMENT",first,LT(1))).add(typeArgument_AST));
3968 			currentAST.root = typeArgument_AST;
3969 			currentAST.child = typeArgument_AST!=null &&typeArgument_AST.getFirstChild()!=null ?
3970 				typeArgument_AST.getFirstChild() : typeArgument_AST;
3971 			currentAST.advanceChildToEnd();
3972 		}
3973 		typeArgument_AST = (AST)currentAST.root;
3974 		returnAST = typeArgument_AST;
3975 	}
3976 	
3977 previous bug bug overview next bug   	public final void wildcardType() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
3978 		
3979 		returnAST = null;
3980 		ASTPair currentAST = new ASTPair();
3981 		AST wildcardType_AST = null;
3982 		
3983 		AST tmp91_AST = null;
3984 		tmp91_AST = astFactory.create(LT(1));
3985 		astFactory.addASTChild(currentAST, tmp91_AST);
3986 		match(QUESTION);
3987 		{
3988 		boolean synPredMatched54 = false;
3989 		if (((LA(1)==LITERAL_extends||LA(1)==LITERAL_super) && (LA(2)==IDENT||LA(2)==NLS))) {
3990 			int _m54 = mark();
3991 			synPredMatched54 = true;
3992 			inputState.guessing++;
3993 			try {
3994 				{
3995 				switch ( LA(1)) {
3996 				case LITERAL_extends:
3997 				{
3998 					match(LITERAL_extends);
3999 					break;
4000 				}
4001 				case LITERAL_super:
4002 				{
4003 					match(LITERAL_super);
4004 					break;
4005 				}
4006 				default:
4007 				{
4008 					throw new NoViableAltException(LT(1), getFilename());
4009 				}
4010 				}
4011 				}
4012 			}
4013 			catch (RecognitionException pe) {
4014 				synPredMatched54 = false;
4015 			}
4016 			rewind(_m54);
4017 inputState.guessing--;
4018 		}
4019 		if ( synPredMatched54 ) {
4020 			typeArgumentBounds();
4021 			astFactory.addASTChild(currentAST, returnAST);
4022 		}
4023 previous bug bug overview next bug   		else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_3.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
4024 		}
4025 		else {
4026 			throw new NoViableAltException(LT(1), getFilename());
4027 		}
4028 		
4029 		}
4030 		if ( inputState.guessing==0 ) {
4031 			wildcardType_AST = (AST)currentAST.root;
4032 			wildcardType_AST.setType(WILDCARD_TYPE);
4033 		}
4034 		wildcardType_AST = (AST)currentAST.root;
4035 		returnAST = wildcardType_AST;
4036 	}
4037 	
4038 previous bug bug overview next bug   	public final void typeArgumentBounds() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
4039 		
4040 		returnAST = null;
4041 		ASTPair currentAST = new ASTPair();
4042 		AST typeArgumentBounds_AST = null;
4043 		Token first = LT(1);boolean isUpperBounds = false;
4044 		
4045 		{
4046 		switch ( LA(1)) {
4047 		case LITERAL_extends:
4048 		{
4049 			match(LITERAL_extends);
4050 			if ( inputState.guessing==0 ) {
4051 				isUpperBounds=true;
4052 			}
4053 			break;
4054 		}
4055 		case LITERAL_super:
4056 		{
4057 			match(LITERAL_super);
4058 			break;
4059 		}
4060 		default:
4061 		{
4062 			throw new NoViableAltException(LT(1), getFilename());
4063 		}
4064 		}
4065 		}
4066 		nls();
4067 		classOrInterfaceType(true);
4068 		astFactory.addASTChild(currentAST, returnAST);
4069 		nls();
4070 		if ( inputState.guessing==0 ) {
4071 			typeArgumentBounds_AST = (AST)currentAST.root;
4072 			
4073 			if (isUpperBounds)
4074 			{
4075 			typeArgumentBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_UPPER_BOUNDS,"TYPE_UPPER_BOUNDS",first,LT(1))).add(typeArgumentBounds_AST));
4076 			}
4077 			else
4078 			{
4079 			typeArgumentBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_LOWER_BOUNDS,"TYPE_LOWER_BOUNDS",first,LT(1))).add(typeArgumentBounds_AST));
4080 			}
4081 			
4082 			currentAST.root = typeArgumentBounds_AST;
4083 			currentAST.child = typeArgumentBounds_AST!=null &&typeArgumentBounds_AST.getFirstChild()!=null ?
4084 				typeArgumentBounds_AST.getFirstChild() : typeArgumentBounds_AST;
4085 			currentAST.advanceChildToEnd();
4086 		}
4087 		typeArgumentBounds_AST = (AST)currentAST.root;
4088 		returnAST = typeArgumentBounds_AST;
4089 	}
4090 	
4091 	protected final void typeArgumentsOrParametersEnd() throws RecognitionException, TokenStreamException {
4092 		
4093 		returnAST = null;
4094 		ASTPair currentAST = new ASTPair();
4095 		AST typeArgumentsOrParametersEnd_AST = null;
4096 		
4097 		switch ( LA(1)) {
4098 		case GT:
4099 		{
4100 			match(GT);
4101 			if ( inputState.guessing==0 ) {
4102 				ltCounter-=1;
4103 			}
4104 			typeArgumentsOrParametersEnd_AST = (AST)currentAST.root;
4105 			break;
4106 		}
4107 		case SR:
4108 		{
4109 			match(SR);
4110 			if ( inputState.guessing==0 ) {
4111 				ltCounter-=2;
4112 			}
4113 			typeArgumentsOrParametersEnd_AST = (AST)currentAST.root;
4114 			break;
4115 		}
4116 		case BSR:
4117 		{
4118 			match(BSR);
4119 			if ( inputState.guessing==0 ) {
4120 				ltCounter-=3;
4121 			}
4122 			typeArgumentsOrParametersEnd_AST = (AST)currentAST.root;
4123 			break;
4124 		}
4125 		default:
4126 		{
4127 			throw new NoViableAltException(LT(1), getFilename());
4128 		}
4129 		}
4130 		returnAST = typeArgumentsOrParametersEnd_AST;
4131 	}
4132 	
4133 	public final void type() throws RecognitionException, TokenStreamException {
4134 		
4135 		returnAST = null;
4136 		ASTPair currentAST = new ASTPair();
4137 		AST type_AST = null;
4138 		
4139 		switch ( LA(1)) {
4140 		case IDENT:
4141 		{
4142 			classOrInterfaceType(false);
4143 			astFactory.addASTChild(currentAST, returnAST);
4144 			type_AST = (AST)currentAST.root;
4145 			break;
4146 		}
4147 		case LITERAL_void:
4148 		case LITERAL_boolean:
4149 		case LITERAL_byte:
4150 		case LITERAL_char:
4151 		case LITERAL_short:
4152 		case LITERAL_int:
4153 		case LITERAL_float:
4154 		case LITERAL_long:
4155 		case LITERAL_double:
4156 		{
4157 			builtInType();
4158 			astFactory.addASTChild(currentAST, returnAST);
4159 			type_AST = (AST)currentAST.root;
4160 			break;
4161 		}
4162 		default:
4163 		{
4164 			throw new NoViableAltException(LT(1), getFilename());
4165 		}
4166 		}
4167 		returnAST = type_AST;
4168 	}
4169 	
4170 	public final void modifiersInternal() throws RecognitionException, TokenStreamException {
4171 		
4172 		returnAST = null;
4173 		ASTPair currentAST = new ASTPair();
4174 		AST modifiersInternal_AST = null;
4175 		int seenDef = 0;
4176 		
4177 		{
4178 		int _cnt79=0;
4179 		_loop79:
4180 		do {
4181 			if (((LA(1)==LITERAL_def))&&(seenDef++ == 0)) {
4182 				match(LITERAL_def);
4183 				nls();
4184 			}
4185 			else if ((_tokenSet_46.member(LA(1)))) {
4186 				modifier();
4187 				astFactory.addASTChild(currentAST, returnAST);
4188 				nls();
4189 			}
4190 			else if ((LA(1)==AT) && (LA(2)==LITERAL_interface)) {
4191 				if ( inputState.guessing==0 ) {
4192 					break; /* go out of the ()+ loop*/
4193 				}
4194 				AST tmp98_AST = null;
4195 				tmp98_AST = astFactory.create(LT(1));
4196 				astFactory.addASTChild(currentAST, tmp98_AST);
4197 				match(AT);
4198 				AST tmp99_AST = null;
4199 				tmp99_AST = astFactory.create(LT(1));
4200 				astFactory.addASTChild(currentAST, tmp99_AST);
4201 				match(LITERAL_interface);
4202 			}
4203 			else if ((LA(1)==AT) && (LA(2)==IDENT)) {
4204 				annotation();
4205 				astFactory.addASTChild(currentAST, returnAST);
4206 				nls();
4207 			}
4208 			else {
4209 				if ( _cnt79>=1 ) { break _loop79; } else {throw new NoViableAltException(LT(1), getFilename());}
4210 			}
4211 			
4212 			_cnt79++;
4213 		} while (true);
4214 		}
4215 		modifiersInternal_AST = (AST)currentAST.root;
4216 		returnAST = modifiersInternal_AST;
4217 	}
4218 	
4219 	public final void annotationArguments() throws RecognitionException, TokenStreamException {
4220 		
4221 		returnAST = null;
4222 		ASTPair currentAST = new ASTPair();
4223 		AST annotationArguments_AST = null;
4224 		AST v_AST = null;
4225 		
4226 		if ((_tokenSet_47.member(LA(1))) && (_tokenSet_48.member(LA(2)))) {
4227 			annotationMemberValueInitializer();
4228 			v_AST = (AST)returnAST;
4229 			astFactory.addASTChild(currentAST, returnAST);
4230 			if ( inputState.guessing==0 ) {
4231 				annotationArguments_AST = (AST)currentAST.root;
4232 				Token itkn = new Token(IDENT, "value");
4233 				AST i;
4234 				i = (AST)astFactory.make( (new ASTArray(1)).add(create(IDENT,"value",itkn,itkn)));
4235 				annotationArguments_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR",LT(1),LT(1))).add(i).add(v_AST));
4236 				currentAST.root = annotationArguments_AST;
4237 				currentAST.child = annotationArguments_AST!=null &&annotationArguments_AST.getFirstChild()!=null ?
4238 					annotationArguments_AST.getFirstChild() : annotationArguments_AST;
4239 				currentAST.advanceChildToEnd();
4240 			}
4241 			annotationArguments_AST = (AST)currentAST.root;
4242 		}
4243 		else if ((_tokenSet_49.member(LA(1))) && (LA(2)==ASSIGN)) {
4244 			annotationMemberValuePairs();
4245 			astFactory.addASTChild(currentAST, returnAST);
4246 			annotationArguments_AST = (AST)currentAST.root;
4247 		}
4248 		else {
4249 			throw new NoViableAltException(LT(1), getFilename());
4250 		}
4251 		
4252 		returnAST = annotationArguments_AST;
4253 	}
4254 	
4255 	public final void annotationsInternal() throws RecognitionException, TokenStreamException {
4256 		
4257 		returnAST = null;
4258 		ASTPair currentAST = new ASTPair();
4259 		AST annotationsInternal_AST = null;
4260 		
4261 		{
4262 		_loop89:
4263 		do {
4264 			if ((LA(1)==AT) && (LA(2)==LITERAL_interface)) {
4265 				if ( inputState.guessing==0 ) {
4266 					break; /* go out of the ()* loop*/
4267 				}
4268 				AST tmp100_AST = null;
4269 				tmp100_AST = astFactory.create(LT(1));
4270 				astFactory.addASTChild(currentAST, tmp100_AST);
4271 				match(AT);
4272 				AST tmp101_AST = null;
4273 				tmp101_AST = astFactory.create(LT(1));
4274 				astFactory.addASTChild(currentAST, tmp101_AST);
4275 				match(LITERAL_interface);
4276 			}
4277 			else if ((LA(1)==AT) && (LA(2)==IDENT)) {
4278 				annotation();
4279 				astFactory.addASTChild(currentAST, returnAST);
4280 				nls();
4281 			}
4282 			else {
4283 				break _loop89;
4284 			}
4285 			
4286 		} while (true);
4287 		}
4288 		annotationsInternal_AST = (AST)currentAST.root;
4289 		returnAST = annotationsInternal_AST;
4290 	}
4291 	
4292 	public final void annotationMemberValueInitializer() throws RecognitionException, TokenStreamException {
4293 		
4294 		returnAST = null;
4295 		ASTPair currentAST = new ASTPair();
4296 		AST annotationMemberValueInitializer_AST = null;
4297 		
4298 		switch ( LA(1)) {
4299 		case LBRACK:
4300 		case IDENT:
4301 		case STRING_LITERAL:
4302 		case LPAREN:
4303 		case LITERAL_super:
4304 		case LITERAL_void:
4305 		case LITERAL_boolean:
4306 		case LITERAL_byte:
4307 		case LITERAL_char:
4308 		case LITERAL_short:
4309 		case LITERAL_int:
4310 		case LITERAL_float:
4311 		case LITERAL_long:
4312 		case LITERAL_double:
4313 		case LCURLY:
4314 		case LITERAL_this:
4315 		case PLUS:
4316 		case MINUS:
4317 		case LITERAL_false:
4318 		case LITERAL_new:
4319 		case LITERAL_null:
4320 		case LITERAL_true:
4321 		case INC:
4322 		case DEC:
4323 		case BNOT:
4324 		case LNOT:
4325 		case STRING_CTOR_START:
4326 		case NUM_INT:
4327 		case NUM_FLOAT:
4328 		case NUM_LONG:
4329 		case NUM_DOUBLE:
4330 		case NUM_BIG_INT:
4331 		case NUM_BIG_DECIMAL:
4332 		{
4333 			conditionalExpression(0);
4334 			astFactory.addASTChild(currentAST, returnAST);
4335 			annotationMemberValueInitializer_AST = (AST)currentAST.root;
4336 			break;
4337 		}
4338 		case AT:
4339 		{
4340 			annotation();
4341 			astFactory.addASTChild(currentAST, returnAST);
4342 			annotationMemberValueInitializer_AST = (AST)currentAST.root;
4343 			break;
4344 		}
4345 		default:
4346 		{
4347 			throw new NoViableAltException(LT(1), getFilename());
4348 		}
4349 		}
4350 		returnAST = annotationMemberValueInitializer_AST;
4351 	}
4352 	
4353 	public final void annotationMemberValuePairs() throws RecognitionException, TokenStreamException {
4354 		
4355 		returnAST = null;
4356 		ASTPair currentAST = new ASTPair();
4357 		AST annotationMemberValuePairs_AST = null;
4358 		
4359 		annotationMemberValuePair();
4360 		astFactory.addASTChild(currentAST, returnAST);
4361 		{
4362 		_loop95:
4363 		do {
4364 			if ((LA(1)==COMMA)) {
4365 				match(COMMA);
4366 				nls();
4367 				annotationMemberValuePair();
4368 				astFactory.addASTChild(currentAST, returnAST);
4369 			}
4370 			else {
4371 				break _loop95;
4372 			}
4373 			
4374 		} while (true);
4375 		}
4376 		annotationMemberValuePairs_AST = (AST)currentAST.root;
4377 		returnAST = annotationMemberValuePairs_AST;
4378 	}
4379 	
4380 	public final void annotationMemberValuePair() throws RecognitionException, TokenStreamException {
4381 		
4382 		returnAST = null;
4383 		ASTPair currentAST = new ASTPair();
4384 		AST annotationMemberValuePair_AST = null;
4385 		AST i_AST = null;
4386 		AST v_AST = null;
4387 		Token first = LT(1);
4388 		
4389 		annotationIdent();
4390 		i_AST = (AST)returnAST;
4391 		match(ASSIGN);
4392 		nls();
4393 		annotationMemberValueInitializer();
4394 		v_AST = (AST)returnAST;
4395 		if ( inputState.guessing==0 ) {
4396 			annotationMemberValuePair_AST = (AST)currentAST.root;
4397 			annotationMemberValuePair_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR",first,LT(1))).add(i_AST).add(v_AST));
4398 			currentAST.root = annotationMemberValuePair_AST;
4399 			currentAST.child = annotationMemberValuePair_AST!=null &&annotationMemberValuePair_AST.getFirstChild()!=null ?
4400 				annotationMemberValuePair_AST.getFirstChild() : annotationMemberValuePair_AST;
4401 			currentAST.advanceChildToEnd();
4402 		}
4403 		returnAST = annotationMemberValuePair_AST;
4404 	}
4405 	
4406 	public final void annotationIdent() throws RecognitionException, TokenStreamException {
4407 		
4408 		returnAST = null;
4409 		ASTPair currentAST = new ASTPair();
4410 		AST annotationIdent_AST = null;
4411 		
4412 		switch ( LA(1)) {
4413 		case IDENT:
4414 		{
4415 			AST tmp104_AST = null;
4416 			tmp104_AST = astFactory.create(LT(1));
4417 			astFactory.addASTChild(currentAST, tmp104_AST);
4418 			match(IDENT);
4419 			annotationIdent_AST = (AST)currentAST.root;
4420 previous bug bug overview next bug   			break; 
4421 		}
4422 		case FINAL:
4423 		case ABSTRACT:
4424 		case UNUSED_GOTO:
4425 		case UNUSED_CONST:
4426 		case UNUSED_DO:
4427 		case STRICTFP:
4428 		case LITERAL_package:
4429 		case LITERAL_import:
4430 		case LITERAL_static:
4431 		case LITERAL_def:
4432 		case LITERAL_class:
4433 		case LITERAL_interface:
4434 		case LITERAL_enum:
4435 		case LITERAL_extends:
4436 		case LITERAL_super:
4437 		case LITERAL_void:
4438 		case LITERAL_boolean:
4439 		case LITERAL_byte:
4440 		case LITERAL_char:
4441 		case LITERAL_short:
4442 		case LITERAL_int:
4443 		case LITERAL_float:
4444 		case LITERAL_long:
4445 		case LITERAL_double:
4446 		case LITERAL_as:
4447 		case LITERAL_private:
4448 		case LITERAL_public:
4449 		case LITERAL_protected:
4450 		case LITERAL_transient:
4451 		case LITERAL_native:
4452 		case LITERAL_threadsafe:
4453 		case LITERAL_synchronized:
4454 		case LITERAL_volatile:
4455 		case LITERAL_default:
4456 		case LITERAL_throws:
4457 		case LITERAL_implements:
4458 		case LITERAL_this:
4459 		case LITERAL_if:
4460 		case LITERAL_else:
4461 		case LITERAL_while:
4462 		case LITERAL_switch:
4463 		case LITERAL_for:
4464 		case LITERAL_in:
4465 		case LITERAL_return:
4466 		case LITERAL_break:
4467 		case LITERAL_continue:
4468 		case LITERAL_throw:
4469 		case LITERAL_assert:
4470 		case LITERAL_case:
4471 		case LITERAL_try:
4472 		case LITERAL_finally:
4473 		case LITERAL_catch:
4474 		case LITERAL_false:
4475 		case LITERAL_instanceof:
4476 		case LITERAL_new:
4477 		case LITERAL_null:
4478 		case LITERAL_true:
4479 		{
4480 			keywordPropertyNames();
4481 			astFactory.addASTChild(currentAST, returnAST);
4482 			annotationIdent_AST = (AST)currentAST.root;
4483 			break;
4484 		}
4485 		default:
4486 		{
4487 			throw new NoViableAltException(LT(1), getFilename());
4488 		}
4489 		}
4490 		returnAST = annotationIdent_AST;
4491 	}
4492 	
4493 previous bug bug overview next bug   	public final void keywordPropertyNames() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc  ExcessiveMethodLength 
4494 		
4495 		returnAST = null;
4496 		ASTPair currentAST = new ASTPair();
4497 		AST keywordPropertyNames_AST = null;
4498 		
4499 		{
4500 		switch ( LA(1)) {
4501 		case LITERAL_as:
4502 		{
4503 			AST tmp105_AST = null;
4504 			tmp105_AST = astFactory.create(LT(1));
4505 			astFactory.addASTChild(currentAST, tmp105_AST);
4506 			match(LITERAL_as);
4507 			break;
4508 		}
4509 		case LITERAL_assert:
4510 		{
4511 			AST tmp106_AST = null;
4512 			tmp106_AST = astFactory.create(LT(1));
4513 			astFactory.addASTChild(currentAST, tmp106_AST);
4514 			match(LITERAL_assert);
4515 			break;
4516 		}
4517 		case LITERAL_break:
4518 		{
4519 			AST tmp107_AST = null;
4520 			tmp107_AST = astFactory.create(LT(1));
4521 			astFactory.addASTChild(currentAST, tmp107_AST);
4522 			match(LITERAL_break);
4523 			break;
4524 		}
4525 		case LITERAL_case:
4526 		{
4527 			AST tmp108_AST = null;
4528 			tmp108_AST = astFactory.create(LT(1));
4529 			astFactory.addASTChild(currentAST, tmp108_AST);
4530 			match(LITERAL_case);
4531 			break;
4532 		}
4533 		case LITERAL_catch:
4534 		{
4535 			AST tmp109_AST = null;
4536 			tmp109_AST = astFactory.create(LT(1));
4537 			astFactory.addASTChild(currentAST, tmp109_AST);
4538 			match(LITERAL_catch);
4539 			break;
4540 		}
4541 		case LITERAL_class:
4542 		{
4543 			AST tmp110_AST = null;
4544 			tmp110_AST = astFactory.create(LT(1));
4545 			astFactory.addASTChild(currentAST, tmp110_AST);
4546 			match(LITERAL_class);
4547 			break;
4548 		}
4549 		case UNUSED_CONST:
4550 		{
4551 			AST tmp111_AST = null;
4552 			tmp111_AST = astFactory.create(LT(1));
4553 			astFactory.addASTChild(currentAST, tmp111_AST);
4554 			match(UNUSED_CONST);
4555 			break;
4556 		}
4557 		case LITERAL_continue:
4558 		{
4559 			AST tmp112_AST = null;
4560 			tmp112_AST = astFactory.create(LT(1));
4561 			astFactory.addASTChild(currentAST, tmp112_AST);
4562 			match(LITERAL_continue);
4563 			break;
4564 		}
4565 		case LITERAL_def:
4566 		{
4567 			AST tmp113_AST = null;
4568 			tmp113_AST = astFactory.create(LT(1));
4569 			astFactory.addASTChild(currentAST, tmp113_AST);
4570 			match(LITERAL_def);
4571 			break;
4572 		}
4573 		case LITERAL_default:
4574 		{
4575 			AST tmp114_AST = null;
4576 			tmp114_AST = astFactory.create(LT(1));
4577 			astFactory.addASTChild(currentAST, tmp114_AST);
4578 			match(LITERAL_default);
4579 			break;
4580 		}
4581 		case UNUSED_DO:
4582 		{
4583 			AST tmp115_AST = null;
4584 			tmp115_AST = astFactory.create(LT(1));
4585 			astFactory.addASTChild(currentAST, tmp115_AST);
4586 			match(UNUSED_DO);
4587 			break;
4588 		}
4589 		case LITERAL_else:
4590 		{
4591 			AST tmp116_AST = null;
4592 			tmp116_AST = astFactory.create(LT(1));
4593 			astFactory.addASTChild(currentAST, tmp116_AST);
4594 			match(LITERAL_else);
4595 			break;
4596 		}
4597 		case LITERAL_enum:
4598 		{
4599 			AST tmp117_AST = null;
4600 			tmp117_AST = astFactory.create(LT(1));
4601 			astFactory.addASTChild(currentAST, tmp117_AST);
4602 			match(LITERAL_enum);
4603 			break;
4604 		}
4605 		case LITERAL_extends:
4606 		{
4607 			AST tmp118_AST = null;
4608 			tmp118_AST = astFactory.create(LT(1));
4609 			astFactory.addASTChild(currentAST, tmp118_AST);
4610 			match(LITERAL_extends);
4611 			break;
4612 		}
4613 		case LITERAL_false:
4614 		{
4615 			AST tmp119_AST = null;
4616 			tmp119_AST = astFactory.create(LT(1));
4617 			astFactory.addASTChild(currentAST, tmp119_AST);
4618 			match(LITERAL_false);
4619 			break;
4620 		}
4621 		case LITERAL_finally:
4622 		{
4623 			AST tmp120_AST = null;
4624 			tmp120_AST = astFactory.create(LT(1));
4625 			astFactory.addASTChild(currentAST, tmp120_AST);
4626 			match(LITERAL_finally);
4627 			break;
4628 		}
4629 		case LITERAL_for:
4630 		{
4631 			AST tmp121_AST = null;
4632 			tmp121_AST = astFactory.create(LT(1));
4633 			astFactory.addASTChild(currentAST, tmp121_AST);
4634 			match(LITERAL_for);
4635 			break;
4636 		}
4637 		case UNUSED_GOTO:
4638 		{
4639 			AST tmp122_AST = null;
4640 			tmp122_AST = astFactory.create(LT(1));
4641 			astFactory.addASTChild(currentAST, tmp122_AST);
4642 			match(UNUSED_GOTO);
4643 			break;
4644 		}
4645 		case LITERAL_if:
4646 		{
4647 			AST tmp123_AST = null;
4648 			tmp123_AST = astFactory.create(LT(1));
4649 			astFactory.addASTChild(currentAST, tmp123_AST);
4650 			match(LITERAL_if);
4651 			break;
4652 		}
4653 		case LITERAL_implements:
4654 		{
4655 			AST tmp124_AST = null;
4656 			tmp124_AST = astFactory.create(LT(1));
4657 			astFactory.addASTChild(currentAST, tmp124_AST);
4658 			match(LITERAL_implements);
4659 			break;
4660 		}
4661 		case LITERAL_import:
4662 		{
4663 			AST tmp125_AST = null;
4664 			tmp125_AST = astFactory.create(LT(1));
4665 			astFactory.addASTChild(currentAST, tmp125_AST);
4666 			match(LITERAL_import);
4667 			break;
4668 		}
4669 		case LITERAL_in:
4670 		{
4671 			AST tmp126_AST = null;
4672 			tmp126_AST = astFactory.create(LT(1));
4673 			astFactory.addASTChild(currentAST, tmp126_AST);
4674 			match(LITERAL_in);
4675 			break;
4676 		}
4677 		case LITERAL_instanceof:
4678 		{
4679 			AST tmp127_AST = null;
4680 			tmp127_AST = astFactory.create(LT(1));
4681 			astFactory.addASTChild(currentAST, tmp127_AST);
4682 			match(LITERAL_instanceof);
4683 			break;
4684 		}
4685 		case LITERAL_interface:
4686 		{
4687 			AST tmp128_AST = null;
4688 			tmp128_AST = astFactory.create(LT(1));
4689 			astFactory.addASTChild(currentAST, tmp128_AST);
4690 			match(LITERAL_interface);
4691 			break;
4692 		}
4693 		case LITERAL_new:
4694 		{
4695 			AST tmp129_AST = null;
4696 			tmp129_AST = astFactory.create(LT(1));
4697 			astFactory.addASTChild(currentAST, tmp129_AST);
4698 			match(LITERAL_new);
4699 			break;
4700 		}
4701 		case LITERAL_null:
4702 		{
4703 			AST tmp130_AST = null;
4704 			tmp130_AST = astFactory.create(LT(1));
4705 			astFactory.addASTChild(currentAST, tmp130_AST);
4706 			match(LITERAL_null);
4707 			break;
4708 		}
4709 		case LITERAL_package:
4710 		{
4711 			AST tmp131_AST = null;
4712 			tmp131_AST = astFactory.create(LT(1));
4713 			astFactory.addASTChild(currentAST, tmp131_AST);
4714 			match(LITERAL_package);
4715 			break;
4716 		}
4717 		case LITERAL_return:
4718 		{
4719 			AST tmp132_AST = null;
4720 			tmp132_AST = astFactory.create(LT(1));
4721 			astFactory.addASTChild(currentAST, tmp132_AST);
4722 			match(LITERAL_return);
4723 			break;
4724 		}
4725 		case LITERAL_super:
4726 		{
4727 			AST tmp133_AST = null;
4728 			tmp133_AST = astFactory.create(LT(1));
4729 			astFactory.addASTChild(currentAST, tmp133_AST);
4730 			match(LITERAL_super);
4731 			break;
4732 		}
4733 		case LITERAL_switch:
4734 		{
4735 			AST tmp134_AST = null;
4736 			tmp134_AST = astFactory.create(LT(1));
4737 			astFactory.addASTChild(currentAST, tmp134_AST);
4738 			match(LITERAL_switch);
4739 			break;
4740 		}
4741 		case LITERAL_this:
4742 		{
4743 			AST tmp135_AST = null;
4744 			tmp135_AST = astFactory.create(LT(1));
4745 			astFactory.addASTChild(currentAST, tmp135_AST);
4746 			match(LITERAL_this);
4747 			break;
4748 		}
4749 		case LITERAL_throw:
4750 		{
4751 			AST tmp136_AST = null;
4752 			tmp136_AST = astFactory.create(LT(1));
4753 			astFactory.addASTChild(currentAST, tmp136_AST);
4754 			match(LITERAL_throw);
4755 			break;
4756 		}
4757 		case LITERAL_throws:
4758 		{
4759 			AST tmp137_AST = null;
4760 			tmp137_AST = astFactory.create(LT(1));
4761 			astFactory.addASTChild(currentAST, tmp137_AST);
4762 			match(LITERAL_throws);
4763 			break;
4764 		}
4765 		case LITERAL_true:
4766 		{
4767 			AST tmp138_AST = null;
4768 			tmp138_AST = astFactory.create(LT(1));
4769 			astFactory.addASTChild(currentAST, tmp138_AST);
4770 			match(LITERAL_true);
4771 			break;
4772 		}
4773 		case LITERAL_try:
4774 		{
4775 			AST tmp139_AST = null;
4776 			tmp139_AST = astFactory.create(LT(1));
4777 			astFactory.addASTChild(currentAST, tmp139_AST);
4778 			match(LITERAL_try);
4779 			break;
4780 		}
4781 		case LITERAL_while:
4782 		{
4783 			AST tmp140_AST = null;
4784 			tmp140_AST = astFactory.create(LT(1));
4785 			astFactory.addASTChild(currentAST, tmp140_AST);
4786 			match(LITERAL_while);
4787 			break;
4788 		}
4789 		case FINAL:
4790 		case ABSTRACT:
4791 		case STRICTFP:
4792 		case LITERAL_static:
4793 		case LITERAL_private:
4794 		case LITERAL_public:
4795 		case LITERAL_protected:
4796 		case LITERAL_transient:
4797 		case LITERAL_native:
4798 		case LITERAL_threadsafe:
4799 		case LITERAL_synchronized:
4800 		case LITERAL_volatile:
4801 		{
4802 			modifier();
4803 			astFactory.addASTChild(currentAST, returnAST);
4804 			break;
4805 		}
4806 		case LITERAL_void:
4807 		case LITERAL_boolean:
4808 		case LITERAL_byte:
4809 		case LITERAL_char:
4810 		case LITERAL_short:
4811 		case LITERAL_int:
4812 		case LITERAL_float:
4813 		case LITERAL_long:
4814 		case LITERAL_double:
4815 		{
4816 			builtInType();
4817 			astFactory.addASTChild(currentAST, returnAST);
4818 			break;
4819 		}
4820 		default:
4821 		{
4822 			throw new NoViableAltException(LT(1), getFilename());
4823 		}
4824 		}
4825 		}
4826 		if ( inputState.guessing==0 ) {
4827 			keywordPropertyNames_AST = (AST)currentAST.root;
4828 			keywordPropertyNames_AST.setType(IDENT);
4829 		}
4830 		keywordPropertyNames_AST = (AST)currentAST.root;
4831 		returnAST = keywordPropertyNames_AST;
4832 	}
4833 	
4834 previous bug bug overview next bug   	public final void conditionalExpression(  HEALTH4J >>  :  ExcessiveMethodLength 
4835 		int lc_stmt
4836 	) throws RecognitionException, TokenStreamException {
4837 		
4838 		returnAST = null;
4839 		ASTPair currentAST = new ASTPair();
4840 		AST conditionalExpression_AST = null;
4841 		
4842 		logicalOrExpression(lc_stmt);
4843 		astFactory.addASTChild(currentAST, returnAST);
4844 		{
4845 		switch ( LA(1)) {
4846 		case ELVIS_OPERATOR:
4847 		{
4848 			AST tmp141_AST = null;
4849 			tmp141_AST = astFactory.create(LT(1));
4850 			astFactory.makeASTRoot(currentAST, tmp141_AST);
4851 			match(ELVIS_OPERATOR);
4852 			nls();
4853 			conditionalExpression(0);
4854 			astFactory.addASTChild(currentAST, returnAST);
4855 			break;
4856 		}
4857 		case QUESTION:
4858 		{
4859 			AST tmp142_AST = null;
4860 			tmp142_AST = astFactory.create(LT(1));
4861 			astFactory.makeASTRoot(currentAST, tmp142_AST);
4862 			match(QUESTION);
4863 			nls();
4864 			assignmentExpression(0);
4865 			astFactory.addASTChild(currentAST, returnAST);
4866 			nls();
4867 			match(COLON);
4868 			nls();
4869 			conditionalExpression(0);
4870 			astFactory.addASTChild(currentAST, returnAST);
4871 			break;
4872 		}
4873 		case EOF:
4874 		case FINAL:
4875 		case ABSTRACT:
4876 		case UNUSED_GOTO:
4877 		case UNUSED_CONST:
4878 		case UNUSED_DO:
4879 		case STRICTFP:
4880 		case LITERAL_package:
4881 		case LITERAL_import:
4882 		case LITERAL_static:
4883 		case LITERAL_def:
4884 		case LBRACK:
4885 		case RBRACK:
4886 		case IDENT:
4887 		case STRING_LITERAL:
4888 		case LPAREN:
4889 		case LITERAL_class:
4890 		case LITERAL_interface:
4891 		case LITERAL_enum:
4892 		case LITERAL_extends:
4893 		case LITERAL_super:
4894 		case COMMA:
4895 		case LITERAL_void:
4896 		case LITERAL_boolean:
4897 		case LITERAL_byte:
4898 		case LITERAL_char:
4899 		case LITERAL_short:
4900 		case LITERAL_int:
4901 		case LITERAL_float:
4902 		case LITERAL_long:
4903 		case LITERAL_double:
4904 		case LITERAL_as:
4905 		case LITERAL_private:
4906 		case LITERAL_public:
4907 		case LITERAL_protected:
4908 		case LITERAL_transient:
4909 		case LITERAL_native:
4910 		case LITERAL_threadsafe:
4911 		case LITERAL_synchronized:
4912 		case LITERAL_volatile:
4913 		case RPAREN:
4914 		case ASSIGN:
4915 		case LCURLY:
4916 		case RCURLY:
4917 		case SEMI:
4918 		case LITERAL_default:
4919 		case LITERAL_throws:
4920 		case LITERAL_implements:
4921 		case LITERAL_this:
4922 		case CLOSABLE_BLOCK_OP:
4923 		case COLON:
4924 		case LITERAL_if:
4925 		case LITERAL_else:
4926 		case LITERAL_while:
4927 		case LITERAL_switch:
4928 		case LITERAL_for:
4929 		case LITERAL_in:
4930 		case LITERAL_return:
4931 		case LITERAL_break:
4932 		case LITERAL_continue:
4933 		case LITERAL_throw:
4934 		case LITERAL_assert:
4935 		case PLUS:
4936 		case MINUS:
4937 		case LITERAL_case:
4938 		case LITERAL_try:
4939 		case LITERAL_finally:
4940 		case LITERAL_catch:
4941 		case LITERAL_false:
4942 		case LITERAL_instanceof:
4943 		case LITERAL_new:
4944 		case LITERAL_null:
4945 		case LITERAL_true:
4946 		case PLUS_ASSIGN:
4947 		case MINUS_ASSIGN:
4948 		case STAR_ASSIGN:
4949 		case DIV_ASSIGN:
4950 		case MOD_ASSIGN:
4951 		case SR_ASSIGN:
4952 		case BSR_ASSIGN:
4953 		case SL_ASSIGN:
4954 		case BAND_ASSIGN:
4955 		case BXOR_ASSIGN:
4956 		case BOR_ASSIGN:
4957 		case STAR_STAR_ASSIGN:
4958 		case INC:
4959 		case DEC:
4960 		case BNOT:
4961 		case LNOT:
4962 		case STRING_CTOR_START:
4963 		case NUM_INT:
4964 		case NUM_FLOAT:
4965 		case NUM_LONG:
4966 		case NUM_DOUBLE:
4967 		case NUM_BIG_INT:
4968 		case NUM_BIG_DECIMAL:
4969 		case NLS:
4970 		{
4971 			break;
4972 		}
4973 		default:
4974 		{
4975 			throw new NoViableAltException(LT(1), getFilename());
4976 		}
4977 		}
4978 		}
4979 		conditionalExpression_AST = (AST)currentAST.root;
4980 		returnAST = conditionalExpression_AST;
4981 	}
4982 	
4983 	public final void annotationMemberArrayValueInitializer() throws RecognitionException, TokenStreamException {
4984 		
4985 		returnAST = null;
4986 		ASTPair currentAST = new ASTPair();
4987 		AST annotationMemberArrayValueInitializer_AST = null;
4988 		
4989 		switch ( LA(1)) {
4990 		case LBRACK:
4991 		case IDENT:
4992 		case STRING_LITERAL:
4993 		case LPAREN:
4994 		case LITERAL_super:
4995 		case LITERAL_void:
4996 		case LITERAL_boolean:
4997 		case LITERAL_byte:
4998 		case LITERAL_char:
4999 		case LITERAL_short:
5000 		case LITERAL_int:
5001 		case LITERAL_float:
5002 		case LITERAL_long:
5003 		case LITERAL_double:
5004 		case LCURLY:
5005 		case LITERAL_this:
5006 		case PLUS:
5007 		case MINUS:
5008 		case LITERAL_false:
5009 		case LITERAL_new:
5010 		case LITERAL_null:
5011 		case LITERAL_true:
5012 		case INC:
5013 		case DEC:
5014 		case BNOT:
5015 		case LNOT:
5016 		case STRING_CTOR_START:
5017 		case NUM_INT:
5018 		case NUM_FLOAT:
5019 		case NUM_LONG:
5020 		case NUM_DOUBLE:
5021 		case NUM_BIG_INT:
5022 		case NUM_BIG_DECIMAL:
5023 		{
5024 			conditionalExpression(0);
5025 			astFactory.addASTChild(currentAST, returnAST);
5026 			annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
5027 			break;
5028 		}
5029 		case AT:
5030 		{
5031 			annotation();
5032 			astFactory.addASTChild(currentAST, returnAST);
5033 			nls();
5034 			annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
5035 			break;
5036 		}
5037 		default:
5038 		{
5039 			throw new NoViableAltException(LT(1), getFilename());
5040 		}
5041 		}
5042 		returnAST = annotationMemberArrayValueInitializer_AST;
5043 	}
5044 	
5045 	public final void superClassClause() throws RecognitionException, TokenStreamException {
5046 		
5047 		returnAST = null;
5048 		ASTPair currentAST = new ASTPair();
5049 		AST superClassClause_AST = null;
5050 		AST c_AST = null;
5051 		Token first = LT(1);
5052 		
5053 		{
5054 		switch ( LA(1)) {
5055 		case LITERAL_extends:
5056 		{
5057 			match(LITERAL_extends);
5058 			nls();
5059 			classOrInterfaceType(false);
5060 			c_AST = (AST)returnAST;
5061 			nls();
5062 			break;
5063 		}
5064 		case LCURLY:
5065 		case LITERAL_implements:
5066 		{
5067 			break;
5068 		}
5069 		default:
5070 		{
5071 			throw new NoViableAltException(LT(1), getFilename());
5072 		}
5073 		}
5074 		}
5075 		if ( inputState.guessing==0 ) {
5076 			superClassClause_AST = (AST)currentAST.root;
5077 			superClassClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1))).add(c_AST));
5078 			currentAST.root = superClassClause_AST;
5079 			currentAST.child = superClassClause_AST!=null &&superClassClause_AST.getFirstChild()!=null ?
5080 				superClassClause_AST.getFirstChild() : superClassClause_AST;
5081 			currentAST.advanceChildToEnd();
5082 		}
5083 		returnAST = superClassClause_AST;
5084 	}
5085 	
5086 previous bug bug overview next bug   	public final void implementsClause() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
5087 		
5088 		returnAST = null;
5089 		ASTPair currentAST = new ASTPair();
5090 		AST implementsClause_AST = null;
5091 		Token  i = null;
5092 		AST i_AST = null;
5093 		Token first = LT(1);
5094 		
5095 		{
5096 		switch ( LA(1)) {
5097 		case LITERAL_implements:
5098 		{
5099 			i = LT(1);
5100 			i_AST = astFactory.create(i);
5101 			match(LITERAL_implements);
5102 			nls();
5103 			classOrInterfaceType(true);
5104 			astFactory.addASTChild(currentAST, returnAST);
5105 			{
5106 			_loop187:
5107 			do {
5108 				if ((LA(1)==COMMA)) {
5109 					match(COMMA);
5110 					nls();
5111 					classOrInterfaceType(true);
5112 					astFactory.addASTChild(currentAST, returnAST);
5113 				}
5114 				else {
5115 					break _loop187;
5116 				}
5117 				
5118 			} while (true);
5119 			}
5120 			nls();
5121 			break;
5122 		}
5123 		case LCURLY:
5124 		case NLS:
5125 		{
5126 			break;
5127 		}
5128 		default:
5129 		{
5130 			throw new NoViableAltException(LT(1), getFilename());
5131 		}
5132 		}
5133 		}
5134 		if ( inputState.guessing==0 ) {
5135 			implementsClause_AST = (AST)currentAST.root;
5136 			implementsClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE",first,LT(1))).add(implementsClause_AST));
5137 			currentAST.root = implementsClause_AST;
5138 			currentAST.child = implementsClause_AST!=null &&implementsClause_AST.getFirstChild()!=null ?
5139 				implementsClause_AST.getFirstChild() : implementsClause_AST;
5140 			currentAST.advanceChildToEnd();
5141 		}
5142 		implementsClause_AST = (AST)currentAST.root;
5143 		returnAST = implementsClause_AST;
5144 	}
5145 	
5146 previous bug bug overview next bug   	public final void classBlock() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
5147 		
5148 		returnAST = null;
5149 		ASTPair currentAST = new ASTPair();
5150 		AST classBlock_AST = null;
5151 		Token first = LT(1);
5152 		
5153 		match(LCURLY);
5154 		{
5155 		switch ( LA(1)) {
5156 		case FINAL:
5157 		case ABSTRACT:
5158 		case STRICTFP:
5159 		case LITERAL_static:
5160 		case LITERAL_def:
5161 		case IDENT:
5162 		case LITERAL_class:
5163 		case LITERAL_interface:
5164 		case LITERAL_enum:
5165 		case AT:
5166 		case LITERAL_void:
5167 		case LITERAL_boolean:
5168 		case LITERAL_byte:
5169 		case LITERAL_char:
5170 		case LITERAL_short:
5171 		case LITERAL_int:
5172 		case LITERAL_float:
5173 		case LITERAL_long:
5174 		case LITERAL_double:
5175 		case LITERAL_private:
5176 		case LITERAL_public:
5177 		case LITERAL_protected:
5178 		case LITERAL_transient:
5179 		case LITERAL_native:
5180 		case LITERAL_threadsafe:
5181 		case LITERAL_synchronized:
5182 		case LITERAL_volatile:
5183 		case LCURLY:
5184 		{
5185 			classField();
5186 			astFactory.addASTChild(currentAST, returnAST);
5187 			break;
5188 		}
5189 		case RCURLY:
5190 		case SEMI:
5191 		case NLS:
5192 		{
5193 			break;
5194 		}
5195 		default:
5196 		{
5197 			throw new NoViableAltException(LT(1), getFilename());
5198 		}
5199 		}
5200 		}
5201 		{
5202 previous bug bug overview next bug   		_loop122: 
5203 		do {
5204 			if ((LA(1)==SEMI||LA(1)==NLS)) {
5205 				sep();
5206 				{
5207 				switch ( LA(1)) {
5208 				case FINAL:
5209 				case ABSTRACT:
5210 				case STRICTFP:
5211 				case LITERAL_static:
5212 				case LITERAL_def:
5213 				case IDENT:
5214 				case LITERAL_class:
5215 				case LITERAL_interface:
5216 				case LITERAL_enum:
5217 				case AT:
5218 				case LITERAL_void:
5219 				case LITERAL_boolean:
5220 				case LITERAL_byte:
5221 				case LITERAL_char:
5222 				case LITERAL_short:
5223 				case LITERAL_int:
5224 				case LITERAL_float:
5225 				case LITERAL_long:
5226 				case LITERAL_double:
5227 				case LITERAL_private:
5228 				case LITERAL_public:
5229 				case LITERAL_protected:
5230 				case LITERAL_transient:
5231 				case LITERAL_native:
5232 				case LITERAL_threadsafe:
5233 				case LITERAL_synchronized:
5234 				case LITERAL_volatile:
5235 				case LCURLY:
5236 				{
5237 					classField();
5238 					astFactory.addASTChild(currentAST, returnAST);
5239 					break;
5240 				}
5241 				case RCURLY:
5242 				case SEMI:
5243 				case NLS:
5244 				{
5245 					break;
5246 				}
5247 				default:
5248 				{
5249 					throw new NoViableAltException(LT(1), getFilename());
5250 				}
5251 				}
5252 				}
5253 			}
5254 			else {
5255 				break _loop122;
5256 			}
5257 			
5258 		} while (true);
5259 		}
5260 		match(RCURLY);
5261 		if ( inputState.guessing==0 ) {
5262 			classBlock_AST = (AST)currentAST.root;
5263 			classBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(classBlock_AST));
5264 			currentAST.root = classBlock_AST;
5265 			currentAST.child = classBlock_AST!=null &&classBlock_AST.getFirstChild()!=null ?
5266 				classBlock_AST.getFirstChild() : classBlock_AST;
5267 			currentAST.advanceChildToEnd();
5268 		}
5269 		classBlock_AST = (AST)currentAST.root;
5270 		returnAST = classBlock_AST;
5271 	}
5272 	
5273 previous bug bug overview next bug   	public final void interfaceExtends() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
5274 		
5275 		returnAST = null;
5276 		ASTPair currentAST = new ASTPair();
5277 		AST interfaceExtends_AST = null;
5278 		Token  e = null;
5279 		AST e_AST = null;
5280 		Token first = LT(1);
5281 		
5282 		{
5283 		switch ( LA(1)) {
5284 		case LITERAL_extends:
5285 		{
5286 			e = LT(1);
5287 			e_AST = astFactory.create(e);
5288 			match(LITERAL_extends);
5289 			nls();
5290 			classOrInterfaceType(true);
5291 			astFactory.addASTChild(currentAST, returnAST);
5292 			{
5293 			_loop183:
5294 			do {
5295 				if ((LA(1)==COMMA)) {
5296 					match(COMMA);
5297 					nls();
5298 					classOrInterfaceType(true);
5299 					astFactory.addASTChild(currentAST, returnAST);
5300 				}
5301 				else {
5302 					break _loop183;
5303 				}
5304 				
5305 			} while (true);
5306 			}
5307 			nls();
5308 			break;
5309 		}
5310 		case LCURLY:
5311 		{
5312 			break;
5313 		}
5314 		default:
5315 		{
5316 			throw new NoViableAltException(LT(1), getFilename());
5317 		}
5318 		}
5319 		}
5320 		if ( inputState.guessing==0 ) {
5321 			interfaceExtends_AST = (AST)currentAST.root;
5322 			interfaceExtends_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1))).add(interfaceExtends_AST));
5323 			currentAST.root = interfaceExtends_AST;
5324 			currentAST.child = interfaceExtends_AST!=null &&interfaceExtends_AST.getFirstChild()!=null ?
5325 				interfaceExtends_AST.getFirstChild() : interfaceExtends_AST;
5326 			currentAST.advanceChildToEnd();
5327 		}
5328 		interfaceExtends_AST = (AST)currentAST.root;
5329 		returnAST = interfaceExtends_AST;
5330 	}
5331 	
5332 previous bug bug overview next bug   	public final void interfaceBlock() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
5333 		
5334 		returnAST = null;
5335 		ASTPair currentAST = new ASTPair();
5336 		AST interfaceBlock_AST = null;
5337 		Token first = LT(1);
5338 		
5339 		match(LCURLY);
5340 		{
5341 		switch ( LA(1)) {
5342 		case FINAL:
5343 		case ABSTRACT:
5344 		case STRICTFP:
5345 		case LITERAL_static:
5346 		case LITERAL_def:
5347 		case IDENT:
5348 		case LITERAL_class:
5349 		case LITERAL_interface:
5350 		case LITERAL_enum:
5351 		case AT:
5352 		case LITERAL_void:
5353 		case LITERAL_boolean:
5354 		case LITERAL_byte:
5355 		case LITERAL_char:
5356 		case LITERAL_short:
5357 		case LITERAL_int:
5358 		case LITERAL_float:
5359 		case LITERAL_long:
5360 		case LITERAL_double:
5361 		case LITERAL_private:
5362 		case LITERAL_public:
5363 		case LITERAL_protected:
5364 		case LITERAL_transient:
5365 		case LITERAL_native:
5366 		case LITERAL_threadsafe:
5367 		case LITERAL_synchronized:
5368 		case LITERAL_volatile:
5369 		{
5370 			interfaceField();
5371 			astFactory.addASTChild(currentAST, returnAST);
5372 			break;
5373 		}
5374 		case RCURLY:
5375 		case SEMI:
5376 		case NLS:
5377 		{
5378 			break;
5379 		}
5380 		default:
5381 		{
5382 			throw new NoViableAltException(LT(1), getFilename());
5383 		}
5384 		}
5385 		}
5386 		{
5387 		_loop127:
5388 		do {
5389 			if ((LA(1)==SEMI||LA(1)==NLS)) {
5390 				sep();
5391 				{
5392 				switch ( LA(1)) {
5393 				case FINAL:
5394 				case ABSTRACT:
5395 				case STRICTFP:
5396 				case LITERAL_static:
5397 				case LITERAL_def:
5398 				case IDENT:
5399 				case LITERAL_class:
5400 				case LITERAL_interface:
5401 				case LITERAL_enum:
5402 				case AT:
5403 				case LITERAL_void:
5404 				case LITERAL_boolean:
5405 				case LITERAL_byte:
5406 				case LITERAL_char:
5407 				case LITERAL_short:
5408 				case LITERAL_int:
5409 				case LITERAL_float:
5410 				case LITERAL_long:
5411 				case LITERAL_double:
5412 				case LITERAL_private:
5413 				case LITERAL_public:
5414 				case LITERAL_protected:
5415 				case LITERAL_transient:
5416 				case LITERAL_native:
5417 				case LITERAL_threadsafe:
5418 				case LITERAL_synchronized:
5419 				case LITERAL_volatile:
5420 				{
5421 					interfaceField();
5422 					astFactory.addASTChild(currentAST, returnAST);
5423 					break;
5424 				}
5425 				case RCURLY:
5426 				case SEMI:
5427 				case NLS:
5428 				{
5429 					break;
5430 				}
5431 				default:
5432 				{
5433 					throw new NoViableAltException(LT(1), getFilename());
5434 				}
5435 				}
5436 				}
5437 			}
5438 			else {
5439 				break _loop127;
5440 			}
5441 			
5442 		} while (true);
5443 		}
5444 		match(RCURLY);
5445 		if ( inputState.guessing==0 ) {
5446 			interfaceBlock_AST = (AST)currentAST.root;
5447 			interfaceBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(interfaceBlock_AST));
5448 			currentAST.root = interfaceBlock_AST;
5449 			currentAST.child = interfaceBlock_AST!=null &&interfaceBlock_AST.getFirstChild()!=null ?
5450 				interfaceBlock_AST.getFirstChild() : interfaceBlock_AST;
5451 			currentAST.advanceChildToEnd();
5452 		}
5453 		interfaceBlock_AST = (AST)currentAST.root;
5454 		returnAST = interfaceBlock_AST;
5455 	}
5456 	
5457 previous bug bug overview next bug   	public final void enumBlock() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc  ExcessiveMethodLength 
5458 		
5459 		returnAST = null;
5460 		ASTPair currentAST = new ASTPair();
5461 		AST enumBlock_AST = null;
5462 		Token first = LT(1);
5463 		
5464 		match(LCURLY);
5465 		nls();
5466 		{
5467 		boolean synPredMatched136 = false;
5468 		if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_50.member(LA(2))))) {
5469 			int _m136 = mark();
5470 			synPredMatched136 = true;
5471 			inputState.guessing++;
5472 			try {
5473 				{
5474 				enumConstantsStart();
5475 				}
5476 			}
5477 			catch (RecognitionException pe) {
5478 				synPredMatched136 = false;
5479 			}
5480 			rewind(_m136);
5481 inputState.guessing--;
5482 		}
5483 		if ( synPredMatched136 ) {
5484 			enumConstants();
5485 			astFactory.addASTChild(currentAST, returnAST);
5486 		}
5487 		else if ((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2)))) {
5488 			{
5489 			switch ( LA(1)) {
5490 			case FINAL:
5491 			case ABSTRACT:
5492 			case STRICTFP:
5493 			case LITERAL_static:
5494 			case LITERAL_def:
5495 			case IDENT:
5496 			case LITERAL_class:
5497 			case LITERAL_interface:
5498 			case LITERAL_enum:
5499 			case AT:
5500 			case LITERAL_void:
5501 			case LITERAL_boolean:
5502 			case LITERAL_byte:
5503 			case LITERAL_char:
5504 			case LITERAL_short:
5505 			case LITERAL_int:
5506 			case LITERAL_float:
5507 			case LITERAL_long:
5508 			case LITERAL_double:
5509 			case LITERAL_private:
5510 			case LITERAL_public:
5511 			case LITERAL_protected:
5512 			case LITERAL_transient:
5513 			case LITERAL_native:
5514 			case LITERAL_threadsafe:
5515 			case LITERAL_synchronized:
5516 			case LITERAL_volatile:
5517 			case LCURLY:
5518 			{
5519 				classField();
5520 				astFactory.addASTChild(currentAST, returnAST);
5521 				break;
5522 			}
5523 			case RCURLY:
5524 			case SEMI:
5525 			case NLS:
5526 			{
5527 				break;
5528 			}
5529 			default:
5530 			{
5531 				throw new NoViableAltException(LT(1), getFilename());
5532 			}
5533 			}
5534 			}
5535 		}
5536 		else {
5537 			throw new NoViableAltException(LT(1), getFilename());
5538 		}
5539 		
5540 		}
5541 		{
5542 		_loop140:
5543 		do {
5544 			if ((LA(1)==SEMI||LA(1)==NLS)) {
5545 				sep();
5546 				{
5547 				switch ( LA(1)) {
5548 				case FINAL:
5549 				case ABSTRACT:
5550 				case STRICTFP:
5551 				case LITERAL_static:
5552 				case LITERAL_def:
5553 				case IDENT:
5554 				case LITERAL_class:
5555 				case LITERAL_interface:
5556 				case LITERAL_enum:
5557 				case AT:
5558 				case LITERAL_void:
5559 				case LITERAL_boolean:
5560 				case LITERAL_byte:
5561 				case LITERAL_char:
5562 				case LITERAL_short:
5563 				case LITERAL_int:
5564 				case LITERAL_float:
5565 				case LITERAL_long:
5566 				case LITERAL_double:
5567 				case LITERAL_private:
5568 				case LITERAL_public:
5569 				case LITERAL_protected:
5570 				case LITERAL_transient:
5571 				case LITERAL_native:
5572 				case LITERAL_threadsafe:
5573 				case LITERAL_synchronized:
5574 				case LITERAL_volatile:
5575 				case LCURLY:
5576 				{
5577 					classField();
5578 					astFactory.addASTChild(currentAST, returnAST);
5579 					break;
5580 				}
5581 				case RCURLY:
5582 				case SEMI:
5583 				case NLS:
5584 				{
5585 					break;
5586 				}
5587 				default:
5588 				{
5589 					throw new NoViableAltException(LT(1), getFilename());
5590 				}
5591 				}
5592 				}
5593 			}
5594 			else {
5595 				break _loop140;
5596 			}
5597 			
5598 		} while (true);
5599 		}
5600 		match(RCURLY);
5601 		if ( inputState.guessing==0 ) {
5602 			enumBlock_AST = (AST)currentAST.root;
5603 			enumBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(enumBlock_AST));
5604 			currentAST.root = enumBlock_AST;
5605 			currentAST.child = enumBlock_AST!=null &&enumBlock_AST.getFirstChild()!=null ?
5606 				enumBlock_AST.getFirstChild() : enumBlock_AST;
5607 			currentAST.advanceChildToEnd();
5608 		}
5609 		enumBlock_AST = (AST)currentAST.root;
5610 		returnAST = enumBlock_AST;
5611 	}
5612 	
5613 previous bug bug overview next bug   	public final void annotationBlock() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
5614 		
5615 		returnAST = null;
5616 		ASTPair currentAST = new ASTPair();
5617 		AST annotationBlock_AST = null;
5618 		Token first = LT(1);
5619 		
5620 		match(LCURLY);
5621 		{
5622 		switch ( LA(1)) {
5623 		case FINAL:
5624 		case ABSTRACT:
5625 		case STRICTFP:
5626 		case LITERAL_static:
5627 		case LITERAL_def:
5628 		case IDENT:
5629 		case LITERAL_class:
5630 		case LITERAL_interface:
5631 		case LITERAL_enum:
5632 		case AT:
5633 		case LITERAL_void:
5634 		case LITERAL_boolean:
5635 		case LITERAL_byte:
5636 		case LITERAL_char:
5637 		case LITERAL_short:
5638 		case LITERAL_int:
5639 		case LITERAL_float:
5640 		case LITERAL_long:
5641 		case LITERAL_double:
5642 		case LITERAL_private:
5643 		case LITERAL_public:
5644 		case LITERAL_protected:
5645 		case LITERAL_transient:
5646 		case LITERAL_native:
5647 		case LITERAL_threadsafe:
5648 		case LITERAL_synchronized:
5649 		case LITERAL_volatile:
5650 		{
5651 			annotationField();
5652 			astFactory.addASTChild(currentAST, returnAST);
5653 			break;
5654 		}
5655 		case RCURLY:
5656 		case SEMI:
5657 		case NLS:
5658 		{
5659 			break;
5660 		}
5661 		default:
5662 		{
5663 			throw new NoViableAltException(LT(1), getFilename());
5664 		}
5665 		}
5666 		}
5667 		{
5668 		_loop132:
5669 		do {
5670 			if ((LA(1)==SEMI||LA(1)==NLS)) {
5671 				sep();
5672 				{
5673 				switch ( LA(1)) {
5674 				case FINAL:
5675 				case ABSTRACT:
5676 				case STRICTFP:
5677 				case LITERAL_static:
5678 				case LITERAL_def:
5679 				case IDENT:
5680 				case LITERAL_class:
5681 				case LITERAL_interface:
5682 				case LITERAL_enum:
5683 				case AT:
5684 				case LITERAL_void:
5685 				case LITERAL_boolean:
5686 				case LITERAL_byte:
5687 				case LITERAL_char:
5688 				case LITERAL_short:
5689 				case LITERAL_int:
5690 				case LITERAL_float:
5691 				case LITERAL_long:
5692 				case LITERAL_double:
5693 				case LITERAL_private:
5694 				case LITERAL_public:
5695 				case LITERAL_protected:
5696 				case LITERAL_transient:
5697 				case LITERAL_native:
5698 				case LITERAL_threadsafe:
5699 				case LITERAL_synchronized:
5700 				case LITERAL_volatile:
5701 				{
5702 					annotationField();
5703 					astFactory.addASTChild(currentAST, returnAST);
5704 					break;
5705 				}
5706 				case RCURLY:
5707 				case SEMI:
5708 				case NLS:
5709 				{
5710 					break;
5711 				}
5712 				default:
5713 				{
5714 					throw new NoViableAltException(LT(1), getFilename());
5715 				}
5716 				}
5717 				}
5718 			}
5719 			else {
5720 				break _loop132;
5721 			}
5722 			
5723 		} while (true);
5724 		}
5725 		match(RCURLY);
5726 		if ( inputState.guessing==0 ) {
5727 			annotationBlock_AST = (AST)currentAST.root;
5728 			annotationBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(annotationBlock_AST));
5729 			currentAST.root = annotationBlock_AST;
5730 			currentAST.child = annotationBlock_AST!=null &&annotationBlock_AST.getFirstChild()!=null ?
5731 				annotationBlock_AST.getFirstChild() : annotationBlock_AST;
5732 			currentAST.advanceChildToEnd();
5733 		}
5734 		annotationBlock_AST = (AST)currentAST.root;
5735 		returnAST = annotationBlock_AST;
5736 	}
5737 	
5738 	public final void typeParameter() throws RecognitionException, TokenStreamException {
5739 		
5740 		returnAST = null;
5741 		ASTPair currentAST = new ASTPair();
5742 		AST typeParameter_AST = null;
5743 		Token  id = null;
5744 		AST id_AST = null;
5745 		Token first = LT(1);
5746 		
5747 		{
5748 		id = LT(1);
5749 		id_AST = astFactory.create(id);
5750 		astFactory.addASTChild(currentAST, id_AST);
5751 		match(IDENT);
5752 		}
5753 		{
5754 		if ((LA(1)==LITERAL_extends) && (LA(2)==IDENT||LA(2)==NLS)) {
5755 			typeParameterBounds();
5756 			astFactory.addASTChild(currentAST, returnAST);
5757 		}
5758 previous bug bug overview next bug   		else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_54.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
5759 		}
5760 		else {
5761 			throw new NoViableAltException(LT(1), getFilename());
5762 		}
5763 		
5764 		}
5765 		if ( inputState.guessing==0 ) {
5766 			typeParameter_AST = (AST)currentAST.root;
5767 			typeParameter_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_PARAMETER,"TYPE_PARAMETER",first,LT(1))).add(typeParameter_AST));
5768 			currentAST.root = typeParameter_AST;
5769 			currentAST.child = typeParameter_AST!=null &&typeParameter_AST.getFirstChild()!=null ?
5770 				typeParameter_AST.getFirstChild() : typeParameter_AST;
5771 			currentAST.advanceChildToEnd();
5772 		}
5773 		typeParameter_AST = (AST)currentAST.root;
5774 		returnAST = typeParameter_AST;
5775 	}
5776 	
5777 	public final void typeParameterBounds() throws RecognitionException, TokenStreamException {
5778 		
5779 		returnAST = null;
5780 		ASTPair currentAST = new ASTPair();
5781 		AST typeParameterBounds_AST = null;
5782 		Token first = LT(1);
5783 		
5784 		match(LITERAL_extends);
5785 		nls();
5786 		classOrInterfaceType(true);
5787 		astFactory.addASTChild(currentAST, returnAST);
5788 		{
5789 		_loop117:
5790 		do {
5791 			if ((LA(1)==BAND)) {
5792 				match(BAND);
5793 				nls();
5794 				classOrInterfaceType(true);
5795 				astFactory.addASTChild(currentAST, returnAST);
5796 			}
5797 			else {
5798 				break _loop117;
5799 			}
5800 			
5801 		} while (true);
5802 		}
5803 		if ( inputState.guessing==0 ) {
5804 			typeParameterBounds_AST = (AST)currentAST.root;
5805 			typeParameterBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_UPPER_BOUNDS,"TYPE_UPPER_BOUNDS",first,LT(1))).add(typeParameterBounds_AST));
5806 			currentAST.root = typeParameterBounds_AST;
5807 			currentAST.child = typeParameterBounds_AST!=null &&typeParameterBounds_AST.getFirstChild()!=null ?
5808 				typeParameterBounds_AST.getFirstChild() : typeParameterBounds_AST;
5809 			currentAST.advanceChildToEnd();
5810 		}
5811 		typeParameterBounds_AST = (AST)currentAST.root;
5812 		returnAST = typeParameterBounds_AST;
5813 	}
5814 	
5815 previous bug bug overview next bug   	public final void classField() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc  ExcessiveMethodLength 
5816 		
5817 		returnAST = null;
5818 		ASTPair currentAST = new ASTPair();
5819 		AST classField_AST = null;
5820 		AST mc_AST = null;
5821 		AST ctor_AST = null;
5822 		AST dg_AST = null;
5823 		AST mad_AST = null;
5824 		AST dd_AST = null;
5825 		AST mods_AST = null;
5826 		AST td_AST = null;
5827 		AST s3_AST = null;
5828 		AST s4_AST = null;
5829 		Token first = LT(1);
5830 		
5831 		boolean synPredMatched190 = false;
5832 		if (((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2))))) {
5833 			int _m190 = mark();
5834 			synPredMatched190 = true;
5835 			inputState.guessing++;
5836 			try {
5837 				{
5838 				constructorStart();
5839 				}
5840 			}
5841 			catch (RecognitionException pe) {
5842 				synPredMatched190 = false;
5843 			}
5844 			rewind(_m190);
5845 inputState.guessing--;
5846 		}
5847 		if ( synPredMatched190 ) {
5848 			modifiersOpt();
5849 			mc_AST = (AST)returnAST;
5850 			constructorDefinition(mc_AST);
5851 			ctor_AST = (AST)returnAST;
5852 			if ( inputState.guessing==0 ) {
5853 				classField_AST = (AST)currentAST.root;
5854 				classField_AST = ctor_AST;
5855 				currentAST.root = classField_AST;
5856 				currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
5857 					classField_AST.getFirstChild() : classField_AST;
5858 				currentAST.advanceChildToEnd();
5859 			}
5860 		}
5861 		else {
5862 			boolean synPredMatched192 = false;
5863 			if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))))) {
5864 				int _m192 = mark();
5865 				synPredMatched192 = true;
5866 				inputState.guessing++;
5867 				try {
5868 					{
5869 					genericMethodStart();
5870 					}
5871 				}
5872 				catch (RecognitionException pe) {
5873 					synPredMatched192 = false;
5874 				}
5875 				rewind(_m192);
5876 inputState.guessing--;
5877 			}
5878 			if ( synPredMatched192 ) {
5879 				genericMethod();
5880 				dg_AST = (AST)returnAST;
5881 				if ( inputState.guessing==0 ) {
5882 					classField_AST = (AST)currentAST.root;
5883 					classField_AST = dg_AST;
5884 					currentAST.root = classField_AST;
5885 					currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
5886 						classField_AST.getFirstChild() : classField_AST;
5887 					currentAST.advanceChildToEnd();
5888 				}
5889 			}
5890 			else {
5891 				boolean synPredMatched194 = false;
5892 				if (((_tokenSet_12.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
5893 					int _m194 = mark();
5894 					synPredMatched194 = true;
5895 					inputState.guessing++;
5896 					try {
5897 						{
5898 						multipleAssignmentDeclarationStart();
5899 						}
5900 					}
5901 					catch (RecognitionException pe) {
5902 						synPredMatched194 = false;
5903 					}
5904 					rewind(_m194);
5905 inputState.guessing--;
5906 				}
5907 				if ( synPredMatched194 ) {
5908 					multipleAssignmentDeclaration();
5909 					mad_AST = (AST)returnAST;
5910 					if ( inputState.guessing==0 ) {
5911 						classField_AST = (AST)currentAST.root;
5912 						classField_AST = mad_AST;
5913 						currentAST.root = classField_AST;
5914 						currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
5915 							classField_AST.getFirstChild() : classField_AST;
5916 						currentAST.advanceChildToEnd();
5917 					}
5918 				}
5919 				else {
5920 					boolean synPredMatched196 = false;
5921 					if (((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
5922 						int _m196 = mark();
5923 						synPredMatched196 = true;
5924 						inputState.guessing++;
5925 						try {
5926 							{
5927 							declarationStart();
5928 							}
5929 						}
5930 						catch (RecognitionException pe) {
5931 							synPredMatched196 = false;
5932 						}
5933 						rewind(_m196);
5934 inputState.guessing--;
5935 					}
5936 					if ( synPredMatched196 ) {
5937 						declaration();
5938 						dd_AST = (AST)returnAST;
5939 						if ( inputState.guessing==0 ) {
5940 							classField_AST = (AST)currentAST.root;
5941 							classField_AST = dd_AST;
5942 							currentAST.root = classField_AST;
5943 							currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
5944 								classField_AST.getFirstChild() : classField_AST;
5945 							currentAST.advanceChildToEnd();
5946 						}
5947 					}
5948 					else {
5949 						boolean synPredMatched198 = false;
5950 						if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
5951 							int _m198 = mark();
5952 							synPredMatched198 = true;
5953 							inputState.guessing++;
5954 							try {
5955 								{
5956 								typeDeclarationStart();
5957 								}
5958 							}
5959 							catch (RecognitionException pe) {
5960 								synPredMatched198 = false;
5961 							}
5962 							rewind(_m198);
5963 inputState.guessing--;
5964 						}
5965 						if ( synPredMatched198 ) {
5966 							modifiersOpt();
5967 							mods_AST = (AST)returnAST;
5968 							{
5969 							typeDefinitionInternal(mods_AST);
5970 							td_AST = (AST)returnAST;
5971 							if ( inputState.guessing==0 ) {
5972 								classField_AST = (AST)currentAST.root;
5973 								classField_AST = td_AST;
5974 								currentAST.root = classField_AST;
5975 								currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
5976 									classField_AST.getFirstChild() : classField_AST;
5977 								currentAST.advanceChildToEnd();
5978 							}
5979 							}
5980 						}
5981 						else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY||LA(2)==NLS)) {
5982 							match(LITERAL_static);
5983 							nls();
5984 							compoundStatement();
5985 							s3_AST = (AST)returnAST;
5986 							if ( inputState.guessing==0 ) {
5987 								classField_AST = (AST)currentAST.root;
5988 								classField_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(STATIC_INIT,"STATIC_INIT",first,LT(1))).add(s3_AST));
5989 								currentAST.root = classField_AST;
5990 								currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
5991 									classField_AST.getFirstChild() : classField_AST;
5992 								currentAST.advanceChildToEnd();
5993 							}
5994 						}
5995 						else if ((LA(1)==LCURLY)) {
5996 							compoundStatement();
5997 							s4_AST = (AST)returnAST;
5998 							if ( inputState.guessing==0 ) {
5999 								classField_AST = (AST)currentAST.root;
6000 								classField_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(INSTANCE_INIT,"INSTANCE_INIT",first,LT(1))).add(s4_AST));
6001 								currentAST.root = classField_AST;
6002 								currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
6003 									classField_AST.getFirstChild() : classField_AST;
6004 								currentAST.advanceChildToEnd();
6005 							}
6006 						}
6007 						else {
6008 							throw new NoViableAltException(LT(1), getFilename());
6009 						}
6010 						}}}}
6011 						returnAST = classField_AST;
6012 					}
6013 					
6014 previous bug bug overview next bug   	public final void interfaceField() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
6015 		
6016 		returnAST = null;
6017 		ASTPair currentAST = new ASTPair();
6018 		AST interfaceField_AST = null;
6019 		AST d_AST = null;
6020 		AST dg_AST = null;
6021 		AST mods_AST = null;
6022 		AST td_AST = null;
6023 		
6024 		boolean synPredMatched202 = false;
6025 		if (((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
6026 			int _m202 = mark();
6027 			synPredMatched202 = true;
6028 			inputState.guessing++;
6029 			try {
6030 				{
6031 				declarationStart();
6032 				}
6033 			}
6034 			catch (RecognitionException pe) {
6035 				synPredMatched202 = false;
6036 			}
6037 			rewind(_m202);
6038 inputState.guessing--;
6039 		}
6040 		if ( synPredMatched202 ) {
6041 			declaration();
6042 			d_AST = (AST)returnAST;
6043 			if ( inputState.guessing==0 ) {
6044 				interfaceField_AST = (AST)currentAST.root;
6045 				interfaceField_AST = d_AST;
6046 				currentAST.root = interfaceField_AST;
6047 				currentAST.child = interfaceField_AST!=null &&interfaceField_AST.getFirstChild()!=null ?
6048 					interfaceField_AST.getFirstChild() : interfaceField_AST;
6049 				currentAST.advanceChildToEnd();
6050 			}
6051 		}
6052 		else {
6053 			boolean synPredMatched204 = false;
6054 			if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))))) {
6055 				int _m204 = mark();
6056 				synPredMatched204 = true;
6057 				inputState.guessing++;
6058 				try {
6059 					{
6060 					genericMethodStart();
6061 					}
6062 				}
6063 				catch (RecognitionException pe) {
6064 					synPredMatched204 = false;
6065 				}
6066 				rewind(_m204);
6067 inputState.guessing--;
6068 			}
6069 			if ( synPredMatched204 ) {
6070 				genericMethod();
6071 				dg_AST = (AST)returnAST;
6072 				if ( inputState.guessing==0 ) {
6073 					interfaceField_AST = (AST)currentAST.root;
6074 					interfaceField_AST = dg_AST;
6075 					currentAST.root = interfaceField_AST;
6076 					currentAST.child = interfaceField_AST!=null &&interfaceField_AST.getFirstChild()!=null ?
6077 						interfaceField_AST.getFirstChild() : interfaceField_AST;
6078 					currentAST.advanceChildToEnd();
6079 				}
6080 			}
6081 			else {
6082 				boolean synPredMatched206 = false;
6083 				if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
6084 					int _m206 = mark();
6085 					synPredMatched206 = true;
6086 					inputState.guessing++;
6087 					try {
6088 						{
6089 						typeDeclarationStart();
6090 						}
6091 					}
6092 					catch (RecognitionException pe) {
6093 						synPredMatched206 = false;
6094 					}
6095 					rewind(_m206);
6096 inputState.guessing--;
6097 				}
6098 				if ( synPredMatched206 ) {
6099 					modifiersOpt();
6100 					mods_AST = (AST)returnAST;
6101 					{
6102 					typeDefinitionInternal(mods_AST);
6103 					td_AST = (AST)returnAST;
6104 					if ( inputState.guessing==0 ) {
6105 						interfaceField_AST = (AST)currentAST.root;
6106 						interfaceField_AST = td_AST;
6107 						currentAST.root = interfaceField_AST;
6108 						currentAST.child = interfaceField_AST!=null &&interfaceField_AST.getFirstChild()!=null ?
6109 							interfaceField_AST.getFirstChild() : interfaceField_AST;
6110 						currentAST.advanceChildToEnd();
6111 					}
6112 					}
6113 				}
6114 				else {
6115 					throw new NoViableAltException(LT(1), getFilename());
6116 				}
6117 				}}
6118 				returnAST = interfaceField_AST;
6119 			}
6120 			
6121 previous bug bug overview next bug   	public final void annotationField() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
6122 		
6123 		returnAST = null;
6124 		ASTPair currentAST = new ASTPair();
6125 		AST annotationField_AST = null;
6126 		AST mods_AST = null;
6127 		AST td_AST = null;
6128 		AST t_AST = null;
6129 		Token  i = null;
6130 		AST i_AST = null;
6131 		AST amvi_AST = null;
6132 		AST v_AST = null;
6133 		Token first = LT(1);
6134 		
6135 		modifiersOpt();
6136 		mods_AST = (AST)returnAST;
6137 		{
6138 		switch ( LA(1)) {
6139 		case LITERAL_class:
6140 		case LITERAL_interface:
6141 		case LITERAL_enum:
6142 		case AT:
6143 		{
6144 			typeDefinitionInternal(mods_AST);
6145 			td_AST = (AST)returnAST;
6146 			if ( inputState.guessing==0 ) {
6147 				annotationField_AST = (AST)currentAST.root;
6148 				annotationField_AST = td_AST;
6149 				currentAST.root = annotationField_AST;
6150 				currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
6151 					annotationField_AST.getFirstChild() : annotationField_AST;
6152 				currentAST.advanceChildToEnd();
6153 			}
6154 			break;
6155 		}
6156 		case IDENT:
6157 		case LITERAL_void:
6158 		case LITERAL_boolean:
6159 		case LITERAL_byte:
6160 		case LITERAL_char:
6161 		case LITERAL_short:
6162 		case LITERAL_int:
6163 		case LITERAL_float:
6164 		case LITERAL_long:
6165 		case LITERAL_double:
6166 		{
6167 			typeSpec(false);
6168 			t_AST = (AST)returnAST;
6169 			{
6170 			boolean synPredMatched160 = false;
6171 			if (((LA(1)==IDENT) && (LA(2)==LPAREN))) {
6172 				int _m160 = mark();
6173 				synPredMatched160 = true;
6174 				inputState.guessing++;
6175 				try {
6176 					{
6177 					match(IDENT);
6178 					match(LPAREN);
6179 					}
6180 				}
6181 				catch (RecognitionException pe) {
6182 					synPredMatched160 = false;
6183 				}
6184 				rewind(_m160);
6185 inputState.guessing--;
6186 			}
6187 			if ( synPredMatched160 ) {
6188 				i = LT(1);
6189 				i_AST = astFactory.create(i);
6190 				match(IDENT);
6191 				match(LPAREN);
6192 				match(RPAREN);
6193 				{
6194 				switch ( LA(1)) {
6195 				case LITERAL_default:
6196 				{
6197 					match(LITERAL_default);
6198 					nls();
6199 					annotationMemberValueInitializer();
6200 					amvi_AST = (AST)returnAST;
6201 					break;
6202 				}
6203 				case RCURLY:
6204 				case SEMI:
6205 				case NLS:
6206 				{
6207 					break;
6208 				}
6209 				default:
6210 				{
6211 					throw new NoViableAltException(LT(1), getFilename());
6212 				}
6213 				}
6214 				}
6215 				if ( inputState.guessing==0 ) {
6216 					annotationField_AST = (AST)currentAST.root;
6217 					annotationField_AST =
6218 					(AST)astFactory.make( (new ASTArray(5)).add(create(ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF",first,LT(1))).add(mods_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(t_AST))).add(i_AST).add(amvi_AST));
6219 					currentAST.root = annotationField_AST;
6220 					currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
6221 						annotationField_AST.getFirstChild() : annotationField_AST;
6222 					currentAST.advanceChildToEnd();
6223 				}
6224 			}
6225 			else if ((LA(1)==IDENT||LA(1)==STRING_LITERAL) && (_tokenSet_57.member(LA(2)))) {
6226 				variableDefinitions(mods_AST,t_AST);
6227 				v_AST = (AST)returnAST;
6228 				if ( inputState.guessing==0 ) {
6229 					annotationField_AST = (AST)currentAST.root;
6230 					annotationField_AST = v_AST;
6231 					currentAST.root = annotationField_AST;
6232 					currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
6233 						annotationField_AST.getFirstChild() : annotationField_AST;
6234 					currentAST.advanceChildToEnd();
6235 				}
6236 			}
6237 			else {
6238 				throw new NoViableAltException(LT(1), getFilename());
6239 			}
6240 			
6241 			}
6242 			break;
6243 		}
6244 		default:
6245 		{
6246 			throw new NoViableAltException(LT(1), getFilename());
6247 		}
6248 		}
6249 		}
6250 		returnAST = annotationField_AST;
6251 	}
6252 	
6253 /** Guard for enumConstants.  */
6254 previous bug bug overview next bug   	public final void enumConstantsStart() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  ExcessiveMethodLength 
6255 		
6256 		returnAST = null;
6257 		ASTPair currentAST = new ASTPair();
6258 		AST enumConstantsStart_AST = null;
6259 		
6260 		annotationsOpt();
6261 		astFactory.addASTChild(currentAST, returnAST);
6262 		AST tmp161_AST = null;
6263 		tmp161_AST = astFactory.create(LT(1));
6264 		astFactory.addASTChild(currentAST, tmp161_AST);
6265 		match(IDENT);
6266 		{
6267 		switch ( LA(1)) {
6268 		case LCURLY:
6269 		{
6270 			AST tmp162_AST = null;
6271 			tmp162_AST = astFactory.create(LT(1));
6272 			astFactory.addASTChild(currentAST, tmp162_AST);
6273 			match(LCURLY);
6274 			break;
6275 		}
6276 		case LPAREN:
6277 		{
6278 			AST tmp163_AST = null;
6279 			tmp163_AST = astFactory.create(LT(1));
6280 			astFactory.addASTChild(currentAST, tmp163_AST);
6281 			match(LPAREN);
6282 			break;
6283 		}
6284 		case FINAL:
6285 		case ABSTRACT:
6286 		case STRICTFP:
6287 		case LITERAL_static:
6288 		case LITERAL_def:
6289 		case IDENT:
6290 		case AT:
6291 		case COMMA:
6292 		case LITERAL_void:
6293 		case LITERAL_boolean:
6294 		case LITERAL_byte:
6295 		case LITERAL_char:
6296 		case LITERAL_short:
6297 		case LITERAL_int:
6298 		case LITERAL_float:
6299 		case LITERAL_long:
6300 		case LITERAL_double:
6301 		case LITERAL_private:
6302 		case LITERAL_public:
6303 		case LITERAL_protected:
6304 		case LITERAL_transient:
6305 		case LITERAL_native:
6306 		case LITERAL_threadsafe:
6307 		case LITERAL_synchronized:
6308 		case LITERAL_volatile:
6309 		case RCURLY:
6310 		case SEMI:
6311 		case NLS:
6312 		{
6313 			nls();
6314 			astFactory.addASTChild(currentAST, returnAST);
6315 			{
6316 			switch ( LA(1)) {
6317 			case SEMI:
6318 			{
6319 				AST tmp164_AST = null;
6320 				tmp164_AST = astFactory.create(LT(1));
6321 				astFactory.addASTChild(currentAST, tmp164_AST);
6322 				match(SEMI);
6323 				break;
6324 			}
6325 			case COMMA:
6326 			{
6327 				AST tmp165_AST = null;
6328 				tmp165_AST = astFactory.create(LT(1));
6329 				astFactory.addASTChild(currentAST, tmp165_AST);
6330 				match(COMMA);
6331 				break;
6332 			}
6333 			case FINAL:
6334 			case ABSTRACT:
6335 			case STRICTFP:
6336 			case LITERAL_static:
6337 			case LITERAL_def:
6338 			case IDENT:
6339 			case AT:
6340 			case LITERAL_void:
6341 			case LITERAL_boolean:
6342 			case LITERAL_byte:
6343 			case LITERAL_char:
6344 			case LITERAL_short:
6345 			case LITERAL_int:
6346 			case LITERAL_float:
6347 			case LITERAL_long:
6348 			case LITERAL_double:
6349 			case LITERAL_private:
6350 			case LITERAL_public:
6351 			case LITERAL_protected:
6352 			case LITERAL_transient:
6353 			case LITERAL_native:
6354 			case LITERAL_threadsafe:
6355 			case LITERAL_synchronized:
6356 			case LITERAL_volatile:
6357 			{
6358 				declarationStart();
6359 				astFactory.addASTChild(currentAST, returnAST);
6360 				break;
6361 			}
6362 			case RCURLY:
6363 			{
6364 				AST tmp166_AST = null;
6365 				tmp166_AST = astFactory.create(LT(1));
6366 				astFactory.addASTChild(currentAST, tmp166_AST);
6367 				match(RCURLY);
6368 				break;
6369 			}
6370 			default:
6371 			{
6372 				throw new NoViableAltException(LT(1), getFilename());
6373 			}
6374 			}
6375 			}
6376 			break;
6377 		}
6378 		default:
6379 		{
6380 			throw new NoViableAltException(LT(1), getFilename());
6381 		}
6382 		}
6383 		}
6384 		enumConstantsStart_AST = (AST)currentAST.root;
6385 		returnAST = enumConstantsStart_AST;
6386 	}
6387 	
6388 /** Comma-separated list of one or more enum constant definitions.  */
6389 previous bug bug overview next bug   	public final void enumConstants() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  ExcessiveMethodLength 
6390 		
6391 		returnAST = null;
6392 		ASTPair currentAST = new ASTPair();
6393 		AST enumConstants_AST = null;
6394 		
6395 		enumConstant();
6396 		astFactory.addASTChild(currentAST, returnAST);
6397 		{
6398 		_loop155:
6399 		do {
6400 			boolean synPredMatched148 = false;
6401 			if (((_tokenSet_58.member(LA(1))) && (_tokenSet_59.member(LA(2))))) {
6402 				int _m148 = mark();
6403 previous bug bug overview next bug   				synPredMatched148 = true; 
6404 				inputState.guessing++;
6405 				try {
6406 					{
6407 					nls();
6408 					{
6409 					switch ( LA(1)) {
6410 					case RCURLY:
6411 					{
6412 						match(RCURLY);
6413 						break;
6414 					}
6415 					case FINAL:
6416 					case ABSTRACT:
6417 					case STRICTFP:
6418 					case LITERAL_static:
6419 					case LITERAL_def:
6420 					case IDENT:
6421 					case LITERAL_class:
6422 					case LITERAL_interface:
6423 					case LITERAL_enum:
6424 					case AT:
6425 					case LITERAL_void:
6426 					case LITERAL_boolean:
6427 					case LITERAL_byte:
6428 					case LITERAL_char:
6429 					case LITERAL_short:
6430 					case LITERAL_int:
6431 					case LITERAL_float:
6432 					case LITERAL_long:
6433 					case LITERAL_double:
6434 					case LITERAL_private:
6435 					case LITERAL_public:
6436 					case LITERAL_protected:
6437 					case LITERAL_transient:
6438 					case LITERAL_native:
6439 					case LITERAL_threadsafe:
6440 					case LITERAL_synchronized:
6441 					case LITERAL_volatile:
6442 					case LCURLY:
6443 					{
6444 						classField();
6445 						break;
6446 					}
6447 					default:
6448 					{
6449 						throw new NoViableAltException(LT(1), getFilename());
6450 					}
6451 					}
6452 					}
6453 					}
6454 				}
6455 				catch (RecognitionException pe) {
6456 					synPredMatched148 = false;
6457 				}
6458 				rewind(_m148);
6459 inputState.guessing--;
6460 			}
6461 			if ( synPredMatched148 ) {
6462 				if ( inputState.guessing==0 ) {
6463 					break; /* leave ()* loop */
6464 				}
6465 			}
6466 			else if ((LA(1)==COMMA||LA(1)==NLS) && (_tokenSet_60.member(LA(2)))) {
6467 				nls();
6468 				match(COMMA);
6469 				{
6470 				boolean synPredMatched152 = false;
6471 				if (((_tokenSet_58.member(LA(1))) && (_tokenSet_59.member(LA(2))))) {
6472 					int _m152 = mark();
6473 					synPredMatched152 = true;
6474 					inputState.guessing++;
6475 					try {
6476 						{
6477 						nls();
6478 						{
6479 						switch ( LA(1)) {
6480 						case RCURLY:
6481 						{
6482 							match(RCURLY);
6483 							break;
6484 						}
6485 						case FINAL:
6486 						case ABSTRACT:
6487 						case STRICTFP:
6488 						case LITERAL_static:
6489 						case LITERAL_def:
6490 						case IDENT:
6491 						case LITERAL_class:
6492 						case LITERAL_interface:
6493 						case LITERAL_enum:
6494 						case AT:
6495 						case LITERAL_void:
6496 						case LITERAL_boolean:
6497 						case LITERAL_byte:
6498 						case LITERAL_char:
6499 						case LITERAL_short:
6500 						case LITERAL_int:
6501 						case LITERAL_float:
6502 						case LITERAL_long:
6503 						case LITERAL_double:
6504 						case LITERAL_private:
6505 						case LITERAL_public:
6506 						case LITERAL_protected:
6507 						case LITERAL_transient:
6508 						case LITERAL_native:
6509 						case LITERAL_threadsafe:
6510 						case LITERAL_synchronized:
6511 						case LITERAL_volatile:
6512 						case LCURLY:
6513 						{
6514 							classField();
6515 							break;
6516 						}
6517 						default:
6518 						{
6519 							throw new NoViableAltException(LT(1), getFilename());
6520 						}
6521 						}
6522 						}
6523 						}
6524 					}
6525 					catch (RecognitionException pe) {
6526 						synPredMatched152 = false;
6527 					}
6528 					rewind(_m152);
6529 inputState.guessing--;
6530 				}
6531 				if ( synPredMatched152 ) {
6532 					if ( inputState.guessing==0 ) {
6533 						break; /* leave ()* loop */
6534 					}
6535 				}
6536 				else {
6537 					boolean synPredMatched154 = false;
6538 					if (((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2))))) {
6539 						int _m154 = mark();
6540 						synPredMatched154 = true;
6541 						inputState.guessing++;
6542 						try {
6543 							{
6544 							nls();
6545 							annotationsOpt();
6546 							match(IDENT);
6547 							}
6548 						}
6549 						catch (RecognitionException pe) {
6550 							synPredMatched154 = false;
6551 						}
6552 						rewind(_m154);
6553 inputState.guessing--;
6554 					}
6555 					if ( synPredMatched154 ) {
6556 						nls();
6557 						enumConstant();
6558 						astFactory.addASTChild(currentAST, returnAST);
6559 					}
6560 					else {
6561 						throw new NoViableAltException(LT(1), getFilename());
6562 					}
6563 					}
6564 					}
6565 				}
6566 				else {
6567 					break _loop155;
6568 				}
6569 				
6570 			} while (true);
6571 			}
6572 			enumConstants_AST = (AST)currentAST.root;
6573 			returnAST = enumConstants_AST;
6574 		}
6575 		
6576 previous bug bug overview next bug   	public final void enumConstant() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
6577 		
6578 		returnAST = null;
6579 		ASTPair currentAST = new ASTPair();
6580 		AST enumConstant_AST = null;
6581 		AST an_AST = null;
6582 		Token  i = null;
6583 		AST i_AST = null;
6584 		AST a_AST = null;
6585 		AST b_AST = null;
6586 		Token first = LT(1);
6587 		
6588 		annotationsOpt();
6589 		an_AST = (AST)returnAST;
6590 		i = LT(1);
6591 		i_AST = astFactory.create(i);
6592 		match(IDENT);
6593 		{
6594 		switch ( LA(1)) {
6595 		case LPAREN:
6596 		{
6597 			match(LPAREN);
6598 			argList();
6599 			a_AST = (AST)returnAST;
6600 			match(RPAREN);
6601 			break;
6602 		}
6603 		case COMMA:
6604 		case LCURLY:
6605 		case RCURLY:
6606 		case SEMI:
6607 		case NLS:
6608 		{
6609 			break;
6610 		}
6611 		default:
6612 		{
6613 			throw new NoViableAltException(LT(1), getFilename());
6614 		}
6615 		}
6616 		}
6617 		{
6618 		switch ( LA(1)) {
6619 		case LCURLY:
6620 		{
6621 			enumConstantBlock();
6622 			b_AST = (AST)returnAST;
6623 			break;
6624 		}
6625 		case COMMA:
6626 		case RCURLY:
6627 		case SEMI:
6628 		case NLS:
6629 		{
6630 			break;
6631 		}
6632 		default:
6633 		{
6634 			throw new NoViableAltException(LT(1), getFilename());
6635 		}
6636 		}
6637 		}
6638 		if ( inputState.guessing==0 ) {
6639 			enumConstant_AST = (AST)currentAST.root;
6640 			enumConstant_AST = (AST)astFactory.make( (new ASTArray(5)).add(create(ENUM_CONSTANT_DEF,"ENUM_CONSTANT_DEF",first,LT(1))).add(an_AST).add(i_AST).add(a_AST).add(b_AST));
6641 			currentAST.root = enumConstant_AST;
6642 			currentAST.child = enumConstant_AST!=null &&enumConstant_AST.getFirstChild()!=null ?
6643 				enumConstant_AST.getFirstChild() : enumConstant_AST;
6644 			currentAST.advanceChildToEnd();
6645 		}
6646 		returnAST = enumConstant_AST;
6647 	}
6648 	
6649 previous bug bug overview next bug   	public final void argList() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc  ExcessiveMethodLength 
6650 		
6651 		returnAST = null;
6652 		ASTPair currentAST = new ASTPair();
6653 		AST argList_AST = null;
6654 		
6655 		Token first = LT(1);
6656 		Token lastComma = null;
6657 		int hls=0, hls2=0;
6658 		boolean hasClosureList=false;
6659 		boolean trailingComma=false;
6660 		boolean sce=false;
6661 		
6662 		
6663 previous bug bug overview next bug   		{ 
6664 		switch ( LA(1)) {
6665 		case FINAL:
6666 		case ABSTRACT:
6667 		case UNUSED_GOTO:
6668 		case UNUSED_CONST:
6669 		case UNUSED_DO:
6670 		case STRICTFP:
6671 		case LITERAL_package:
6672 		case LITERAL_import:
6673 		case LITERAL_static:
6674 		case LITERAL_def:
6675 		case LBRACK:
6676 		case IDENT:
6677 		case STRING_LITERAL:
6678 		case LPAREN:
6679 		case LITERAL_class:
6680 		case LITERAL_interface:
6681 		case LITERAL_enum:
6682 		case AT:
6683 		case LITERAL_extends:
6684 		case LITERAL_super:
6685 		case LITERAL_void:
6686 		case LITERAL_boolean:
6687 		case LITERAL_byte:
6688 		case LITERAL_char:
6689 		case LITERAL_short:
6690 		case LITERAL_int:
6691 		case LITERAL_float:
6692 		case LITERAL_long:
6693 		case LITERAL_double:
6694 		case STAR:
6695 		case LITERAL_as:
6696 		case LITERAL_private:
6697 		case LITERAL_public:
6698 		case LITERAL_protected:
6699 		case LITERAL_transient:
6700 		case LITERAL_native:
6701 		case LITERAL_threadsafe:
6702 		case LITERAL_synchronized:
6703 		case LITERAL_volatile:
6704 		case LCURLY:
6705 		case LITERAL_default:
6706 		case LITERAL_throws:
6707 		case LITERAL_implements:
6708 		case LITERAL_this:
6709 		case LITERAL_if:
6710 		case LITERAL_else:
6711 		case LITERAL_while:
6712 		case LITERAL_switch:
6713 		case LITERAL_for:
6714 		case LITERAL_in:
6715 		case LITERAL_return:
6716 		case LITERAL_break:
6717 		case LITERAL_continue:
6718 		case LITERAL_throw:
6719 		case LITERAL_assert:
6720 		case PLUS:
6721 		case MINUS:
6722 		case LITERAL_case:
6723 		case LITERAL_try:
6724 		case LITERAL_finally:
6725 		case LITERAL_catch:
6726 		case LITERAL_false:
6727 		case LITERAL_instanceof:
6728 		case LITERAL_new:
6729 		case LITERAL_null:
6730 		case LITERAL_true:
6731 		case INC:
6732 		case DEC:
6733 		case BNOT:
6734 		case LNOT:
6735 		case STRING_CTOR_START:
6736 		case NUM_INT:
6737 		case NUM_FLOAT:
6738 		case NUM_LONG:
6739 		case NUM_DOUBLE:
6740 		case NUM_BIG_INT:
6741 		case NUM_BIG_DECIMAL:
6742 		{
6743 			hls=argument();
6744 			astFactory.addASTChild(currentAST, returnAST);
6745 			{
6746 			switch ( LA(1)) {
6747 			case SEMI:
6748 			{
6749 				{
6750 				{
6751 				int _cnt538=0;
6752 previous bug bug overview next bug   				_loop538: 
6753 				do {
6754 					if ((LA(1)==SEMI)) {
6755 						match(SEMI);
6756 						if ( inputState.guessing==0 ) {
6757 							hasClosureList=true;
6758 						}
6759 						{
6760 						switch ( LA(1)) {
6761 						case FINAL:
6762 						case ABSTRACT:
6763 						case STRICTFP:
6764 						case LITERAL_static:
6765 						case LITERAL_def:
6766 						case LBRACK:
6767 						case IDENT:
6768 						case STRING_LITERAL:
6769 						case LPAREN:
6770 						case AT:
6771 						case LITERAL_super:
6772 						case LITERAL_void:
6773 						case LITERAL_boolean:
6774 						case LITERAL_byte:
6775 						case LITERAL_char:
6776 						case LITERAL_short:
6777 						case LITERAL_int:
6778 						case LITERAL_float:
6779 						case LITERAL_long:
6780 						case LITERAL_double:
6781 						case LITERAL_private:
6782 						case LITERAL_public:
6783 						case LITERAL_protected:
6784 						case LITERAL_transient:
6785 						case LITERAL_native:
6786 						case LITERAL_threadsafe:
6787 						case LITERAL_synchronized:
6788 						case LITERAL_volatile:
6789 						case LCURLY:
6790 						case LITERAL_this:
6791 						case LITERAL_return:
6792 						case LITERAL_break:
6793 						case LITERAL_continue:
6794 						case LITERAL_throw:
6795 						case LITERAL_assert:
6796 						case PLUS:
6797 						case MINUS:
6798 						case LITERAL_false:
6799 						case LITERAL_new:
6800 						case LITERAL_null:
6801 						case LITERAL_true:
6802 						case INC:
6803 						case DEC:
6804 						case BNOT:
6805 						case LNOT:
6806 						case STRING_CTOR_START:
6807 						case NUM_INT:
6808 						case NUM_FLOAT:
6809 						case NUM_LONG:
6810 						case NUM_DOUBLE:
6811 						case NUM_BIG_INT:
6812 						case NUM_BIG_DECIMAL:
6813 						{
6814 							sce=strictContextExpression(true);
6815 							astFactory.addASTChild(currentAST, returnAST);
6816 							break;
6817 						}
6818 						case RBRACK:
6819 						case RPAREN:
6820 						case SEMI:
6821 						{
6822 							if ( inputState.guessing==0 ) {
6823 								astFactory.addASTChild(currentAST,astFactory.create(EMPTY_STAT, "EMPTY_STAT"));
6824 							}
6825 							break;
6826 						}
6827 						default:
6828 						{
6829 							throw new NoViableAltException(LT(1), getFilename());
6830 						}
6831 						}
6832 						}
6833 					}
6834 					else {
6835 						if ( _cnt538>=1 ) { break _loop538; } else {throw new NoViableAltException(LT(1), getFilename());}
6836 					}
6837 					
6838 					_cnt538++;
6839 				} while (true);
6840 				}
6841 				if ( inputState.guessing==0 ) {
6842 					argList_AST = (AST)currentAST.root;
6843 					argList_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(CLOSURE_LIST,"CLOSURE_LIST",first,LT(1))).add(argList_AST));
6844 					currentAST.root = argList_AST;
6845 					currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ?
6846 						argList_AST.getFirstChild() : argList_AST;
6847 					currentAST.advanceChildToEnd();
6848 				}
6849 				}
6850 				break;
6851 			}
6852 			case RBRACK:
6853 			case COMMA:
6854 			case RPAREN:
6855 			{
6856 				{
6857 				{
6858 				_loop544:
6859 				do {
6860 					if ((LA(1)==COMMA)) {
6861 						if ( inputState.guessing==0 ) {
6862 							lastComma = LT(1);
6863 						}
6864 						match(COMMA);
6865 						{
6866 						switch ( LA(1)) {
6867 						case FINAL:
6868 						case ABSTRACT:
6869 						case UNUSED_GOTO:
6870 						case UNUSED_CONST:
6871 						case UNUSED_DO:
6872 						case STRICTFP:
6873 						case LITERAL_package:
6874 						case LITERAL_import:
6875 						case LITERAL_static:
6876 						case LITERAL_def:
6877 						case LBRACK:
6878 						case IDENT:
6879 						case STRING_LITERAL:
6880 						case LPAREN:
6881 						case LITERAL_class:
6882 						case LITERAL_interface:
6883 						case LITERAL_enum:
6884 						case AT:
6885 						case LITERAL_extends:
6886 						case LITERAL_super:
6887 						case LITERAL_void:
6888 						case LITERAL_boolean:
6889 						case LITERAL_byte:
6890 						case LITERAL_char:
6891 						case LITERAL_short:
6892 						case LITERAL_int:
6893 						case LITERAL_float:
6894 						case LITERAL_long:
6895 						case LITERAL_double:
6896 						case STAR:
6897 						case LITERAL_as:
6898 						case LITERAL_private:
6899 						case LITERAL_public:
6900 						case LITERAL_protected:
6901 						case LITERAL_transient:
6902 						case LITERAL_native:
6903 						case LITERAL_threadsafe:
6904 						case LITERAL_synchronized:
6905 						case LITERAL_volatile:
6906 						case LCURLY:
6907 						case LITERAL_default:
6908 						case LITERAL_throws:
6909 						case LITERAL_implements:
6910 						case LITERAL_this:
6911 						case LITERAL_if:
6912 						case LITERAL_else:
6913 						case LITERAL_while:
6914 						case LITERAL_switch:
6915 						case LITERAL_for:
6916 						case LITERAL_in:
6917 						case LITERAL_return:
6918 						case LITERAL_break:
6919 						case LITERAL_continue:
6920 						case LITERAL_throw:
6921 						case LITERAL_assert:
6922 						case PLUS:
6923 						case MINUS:
6924 						case LITERAL_case:
6925 						case LITERAL_try:
6926 						case LITERAL_finally:
6927 						case LITERAL_catch:
6928 						case LITERAL_false:
6929 						case LITERAL_instanceof:
6930 						case LITERAL_new:
6931 						case LITERAL_null:
6932 						case LITERAL_true:
6933 						case INC:
6934 						case DEC:
6935 						case BNOT:
6936 						case LNOT:
6937 						case STRING_CTOR_START:
6938 						case NUM_INT:
6939 						case NUM_FLOAT:
6940 						case NUM_LONG:
6941 						case NUM_DOUBLE:
6942 						case NUM_BIG_INT:
6943 						case NUM_BIG_DECIMAL:
6944 						{
6945 							{
6946 							hls2=argument();
6947 							astFactory.addASTChild(currentAST, returnAST);
6948 							if ( inputState.guessing==0 ) {
6949 								hls |= hls2;
6950 							}
6951 							}
6952 							break;
6953 						}
6954 						case RBRACK:
6955 						case COMMA:
6956 						case RPAREN:
6957 						{
6958 							{
6959 							if ( inputState.guessing==0 ) {
6960 								if (trailingComma) throw new NoViableAltException(lastComma, getFilename());
6961 								trailingComma=true;
6962 								
6963 							}
6964 							}
6965 							break;
6966 						}
6967 						default:
6968 						{
6969 							throw new NoViableAltException(LT(1), getFilename());
6970 						}
6971 						}
6972 						}
6973 					}
6974 					else {
6975 						break _loop544;
6976 					}
6977 					
6978 				} while (true);
6979 				}
6980 				if ( inputState.guessing==0 ) {
6981 					argList_AST = (AST)currentAST.root;
6982 					argList_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(ELIST,"ELIST",first,LT(1))).add(argList_AST));
6983 					currentAST.root = argList_AST;
6984 					currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ?
6985 						argList_AST.getFirstChild() : argList_AST;
6986 					currentAST.advanceChildToEnd();
6987 				}
6988 				}
6989 				break;
6990 			}
6991 			default:
6992 			{
6993 				throw new NoViableAltException(LT(1), getFilename());
6994 			}
6995 			}
6996 			}
6997 			break;
6998 		}
6999 		case RBRACK:
7000 		case RPAREN:
7001 		{
7002 			{
7003 			if ( inputState.guessing==0 ) {
7004 				argList_AST = (AST)currentAST.root;
7005 				argList_AST = create(ELIST,"ELIST",first,LT(1));
7006 				currentAST.root = argList_AST;
7007 				currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ?
7008 					argList_AST.getFirstChild() : argList_AST;
7009 				currentAST.advanceChildToEnd();
7010 			}
7011 			}
7012 			break;
7013 		}
7014 		default:
7015 		{
7016 			throw new NoViableAltException(LT(1), getFilename());
7017 		}
7018 		}
7019 		}
7020 		if ( inputState.guessing==0 ) {
7021 			argListHasLabels = (hls&1)!=0;
7022 		}
7023 		argList_AST = (AST)currentAST.root;
7024 		returnAST = argList_AST;
7025 	}
7026 	
7027 previous bug bug overview next bug   	public final void enumConstantBlock() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
7028 		
7029 		returnAST = null;
7030 		ASTPair currentAST = new ASTPair();
7031 		AST enumConstantBlock_AST = null;
7032 		Token first = LT(1);
7033 		
7034 		match(LCURLY);
7035 		{
7036 		switch ( LA(1)) {
7037 		case FINAL:
7038 		case ABSTRACT:
7039 		case STRICTFP:
7040 		case LITERAL_static:
7041 		case LITERAL_def:
7042 		case IDENT:
7043 		case LT:
7044 		case LITERAL_class:
7045 		case LITERAL_interface:
7046 		case LITERAL_enum:
7047 		case AT:
7048 		case LITERAL_void:
7049 		case LITERAL_boolean:
7050 		case LITERAL_byte:
7051 		case LITERAL_char:
7052 		case LITERAL_short:
7053 		case LITERAL_int:
7054 		case LITERAL_float:
7055 		case LITERAL_long:
7056 		case LITERAL_double:
7057 		case LITERAL_private:
7058 		case LITERAL_public:
7059 		case LITERAL_protected:
7060 		case LITERAL_transient:
7061 		case LITERAL_native:
7062 		case LITERAL_threadsafe:
7063 		case LITERAL_synchronized:
7064 		case LITERAL_volatile:
7065 		case LCURLY:
7066 		{
7067 			enumConstantField();
7068 			astFactory.addASTChild(currentAST, returnAST);
7069 			break;
7070 		}
7071 		case RCURLY:
7072 		case SEMI:
7073 		case NLS:
7074 		{
7075 			break;
7076 		}
7077 		default:
7078 		{
7079 			throw new NoViableAltException(LT(1), getFilename());
7080 		}
7081 		}
7082 		}
7083 		{
7084 		_loop169:
7085 		do {
7086 			if ((LA(1)==SEMI||LA(1)==NLS)) {
7087 				sep();
7088 				{
7089 				switch ( LA(1)) {
7090 				case FINAL:
7091 				case ABSTRACT:
7092 				case STRICTFP:
7093 				case LITERAL_static:
7094 				case LITERAL_def:
7095 				case IDENT:
7096 				case LT:
7097 				case LITERAL_class:
7098 				case LITERAL_interface:
7099 				case LITERAL_enum:
7100 				case AT:
7101 				case LITERAL_void:
7102 				case LITERAL_boolean:
7103 				case LITERAL_byte:
7104 				case LITERAL_char:
7105 				case LITERAL_short:
7106 				case LITERAL_int:
7107 				case LITERAL_float:
7108 				case LITERAL_long:
7109 				case LITERAL_double:
7110 				case LITERAL_private:
7111 				case LITERAL_public:
7112 				case LITERAL_protected:
7113 				case LITERAL_transient:
7114 				case LITERAL_native:
7115 				case LITERAL_threadsafe:
7116 				case LITERAL_synchronized:
7117 				case LITERAL_volatile:
7118 				case LCURLY:
7119 				{
7120 					enumConstantField();
7121 					astFactory.addASTChild(currentAST, returnAST);
7122 					break;
7123 				}
7124 				case RCURLY:
7125 				case SEMI:
7126 				case NLS:
7127 				{
7128 					break;
7129 				}
7130 				default:
7131 				{
7132 					throw new NoViableAltException(LT(1), getFilename());
7133 				}
7134 				}
7135 				}
7136 			}
7137 			else {
7138 				break _loop169;
7139 			}
7140 			
7141 		} while (true);
7142 		}
7143 		match(RCURLY);
7144 		if ( inputState.guessing==0 ) {
7145 			enumConstantBlock_AST = (AST)currentAST.root;
7146 			enumConstantBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(enumConstantBlock_AST));
7147 			currentAST.root = enumConstantBlock_AST;
7148 			currentAST.child = enumConstantBlock_AST!=null &&enumConstantBlock_AST.getFirstChild()!=null ?
7149 				enumConstantBlock_AST.getFirstChild() : enumConstantBlock_AST;
7150 			currentAST.advanceChildToEnd();
7151 		}
7152 		enumConstantBlock_AST = (AST)currentAST.root;
7153 		returnAST = enumConstantBlock_AST;
7154 	}
7155 	
7156 previous bug bug overview next bug   	public final void enumConstantField() throws RecognitionException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc  ExcessiveMethodLength 
7157 		
7158 		returnAST = null;
7159 		ASTPair currentAST = new ASTPair();
7160 		AST enumConstantField_AST = null;
7161 		AST mods_AST = null;
7162 		AST td_AST = null;
7163 		AST tp_AST = null;
7164 		AST t_AST = null;
7165 		AST param_AST = null;
7166 		AST tc_AST = null;
7167 		AST s2_AST = null;
7168 		AST v_AST = null;
7169 		AST s4_AST = null;
7170 		Token first = LT(1);
7171 		
7172 		switch ( LA(1)) {
7173 		case FINAL:
7174 		case ABSTRACT:
7175 		case STRICTFP:
7176 		case LITERAL_static:
7177 		case LITERAL_def:
7178 		case IDENT:
7179 		case LT:
7180 		case LITERAL_class:
7181 		case LITERAL_interface:
7182 		case LITERAL_enum:
7183 		case AT:
7184 		case LITERAL_void:
7185 		case LITERAL_boolean:
7186 		case LITERAL_byte:
7187 		case LITERAL_char:
7188 		case LITERAL_short:
7189 		case LITERAL_int:
7190 		case LITERAL_float:
7191 		case LITERAL_long:
7192 		case LITERAL_double:
7193 		case LITERAL_private:
7194 		case LITERAL_public:
7195 		case LITERAL_protected:
7196 		case LITERAL_transient:
7197 		case LITERAL_native:
7198 		case LITERAL_threadsafe:
7199 		case LITERAL_synchronized:
7200 		case LITERAL_volatile:
7201 		{
7202 			modifiersOpt();
7203 			mods_AST = (AST)returnAST;
7204 			{
7205 			switch ( LA(1)) {
7206 			case LITERAL_class:
7207 			case LITERAL_interface:
7208 			case LITERAL_enum:
7209 			case AT:
7210 			{
7211 				typeDefinitionInternal(mods_AST);
7212 				td_AST = (AST)returnAST;
7213 				if ( inputState.guessing==0 ) {
7214 					enumConstantField_AST = (AST)currentAST.root;
7215 					enumConstantField_AST = td_AST;
7216 					currentAST.root = enumConstantField_AST;
7217 					currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
7218 						enumConstantField_AST.getFirstChild() : enumConstantField_AST;
7219 					currentAST.advanceChildToEnd();
7220 				}
7221 				break;
7222 			}
7223 			case IDENT:
7224 			case LT:
7225 			case LITERAL_void:
7226 			case LITERAL_boolean:
7227 			case LITERAL_byte:
7228 			case LITERAL_char:
7229 			case LITERAL_short:
7230 			case LITERAL_int:
7231 			case LITERAL_float:
7232 			case LITERAL_long:
7233 			case LITERAL_double:
7234 			{
7235 				{
7236 				switch ( LA(1)) {
7237 				case LT:
7238 				{
7239 					typeParameters();
7240 					tp_AST = (AST)returnAST;
7241 					break;
7242 				}
7243 				case IDENT:
7244 				case LITERAL_void:
7245 				case LITERAL_boolean:
7246 				case LITERAL_byte:
7247 				case LITERAL_char:
7248 				case LITERAL_short:
7249 				case LITERAL_int:
7250 				case LITERAL_float:
7251 				case LITERAL_long:
7252 				case LITERAL_double:
7253 				{
7254 					break;
7255 				}
7256 				default:
7257 				{
7258 					throw new NoViableAltException(LT(1), getFilename());
7259 				}
7260 				}
7261 				}
7262 				typeSpec(false);
7263 				t_AST = (AST)returnAST;
7264 				{
7265 				boolean synPredMatched175 = false;
7266 				if (((LA(1)==IDENT) && (LA(2)==LPAREN))) {
7267 					int _m175 = mark();
7268 					synPredMatched175 = true;
7269 					inputState.guessing++;
7270 					try {
7271 						{
7272 						match(IDENT);
7273 						match(LPAREN);
7274 						}
7275 					}
7276 					catch (RecognitionException pe) {
7277 						synPredMatched175 = false;
7278 					}
7279 					rewind(_m175);
7280 inputState.guessing--;
7281 				}
7282 				if ( synPredMatched175 ) {
7283 					AST tmp174_AST = null;
7284 					tmp174_AST = astFactory.create(LT(1));
7285 					match(IDENT);
7286 					match(LPAREN);
7287 					parameterDeclarationList();
7288 					param_AST = (AST)returnAST;
7289 					match(RPAREN);
7290 					{
7291 					boolean synPredMatched178 = false;
7292 					if (((LA(1)==LITERAL_throws||LA(1)==NLS) && (_tokenSet_28.member(LA(2))))) {
7293 						int _m178 = mark();
7294 						synPredMatched178 = true;
7295 						inputState.guessing++;
7296 						try {
7297 							{
7298 							nls();
7299 							match(LITERAL_throws);
7300 							}
7301 						}
7302 						catch (RecognitionException pe) {
7303 							synPredMatched178 = false;
7304 						}
7305 						rewind(_m178);
7306 inputState.guessing--;
7307 					}
7308 					if ( synPredMatched178 ) {
7309 						throwsClause();
7310 						tc_AST = (AST)returnAST;
7311 					}
7312 previous bug bug overview next bug   					else if ((_tokenSet_63.member(LA(1))) && (_tokenSet_64.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
7313 					}
7314 					else {
7315 						throw new NoViableAltException(LT(1), getFilename());
7316 					}
7317 					
7318 					}
7319 					{
7320 					switch ( LA(1)) {
7321 					case LCURLY:
7322 					{
7323 						compoundStatement();
7324 						s2_AST = (AST)returnAST;
7325 						break;
7326 					}
7327 					case RCURLY:
7328 					case SEMI:
7329 					case NLS:
7330 					{
7331 						break;
7332 					}
7333 					default:
7334 					{
7335 						throw new NoViableAltException(LT(1), getFilename());
7336 					}
7337 					}
7338 					}
7339 					if ( inputState.guessing==0 ) {
7340 						enumConstantField_AST = (AST)currentAST.root;
7341 						enumConstantField_AST = (AST)astFactory.make( (new ASTArray(8)).add(create(METHOD_DEF,"METHOD_DEF",first,LT(1))).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(t_AST))).add(tmp174_AST).add(param_AST).add(tc_AST).add(s2_AST));
7342 						currentAST.root = enumConstantField_AST;
7343 						currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
7344 							enumConstantField_AST.getFirstChild() : enumConstantField_AST;
7345 						currentAST.advanceChildToEnd();
7346 					}
7347 				}
7348 				else if ((LA(1)==IDENT||LA(1)==STRING_LITERAL) && (_tokenSet_57.member(LA(2)))) {
7349 					variableDefinitions(mods_AST,t_AST);
7350 					v_AST = (AST)returnAST;
7351 					if ( inputState.guessing==0 ) {
7352 						enumConstantField_AST = (AST)currentAST.root;
7353 						enumConstantField_AST = v_AST;
7354 						currentAST.root = enumConstantField_AST;
7355 						currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
7356 							enumConstantField_AST.getFirstChild() : enumConstantField_AST;
7357 						currentAST.advanceChildToEnd();
7358 					}
7359 				}
7360 				else {
7361 					throw new NoViableAltException(LT(1), getFilename());
7362 				}
7363 				
7364 				}
7365 				break;
7366 			}
7367 			default:
7368 			{
7369 				throw new NoViableAltException(LT(1), getFilename());
7370 			}
7371 			}
7372 			}
7373 			break;
7374 		}
7375 		case LCURLY:
7376 		{
7377 			compoundStatement();
7378 			s4_AST = (AST)returnAST;
7379 			if ( inputState.guessing==0 ) {
7380 				enumConstantField_AST = (AST)currentAST.root;
7381 				enumConstantField_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(INSTANCE_INIT,"INSTANCE_INIT",first,LT(1))).add(s4_AST));
7382 				currentAST.root = enumConstantField_AST;
7383 				currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
7384 					enumConstantField_AST.getFirstChild() : enumConstantField_AST;
7385 				currentAST.advanceChildToEnd();
7386 			}
7387 			break;
7388 		}
7389 		default:
7390 		{
7391 			throw new NoViableAltException(LT(1), getFilename());
7392 		}
7393 		}
7394 		returnAST = enumConstantField_AST;
7395 	}
7396 	
7397 /** A list of zero or more formal parameters.
7398  *  If a parameter is variable length (e.g. String... myArg) it should be
7399  *  to the right of any other parameters of the same kind.
7400  *  General form:  (req, ..., opt, ..., [rest], key, ..., [restKeys], [block]
7401  *  This must be sorted out after parsing, since the various declaration forms
7402  *  are impossible to tell apart without backtracking.
7403  */
7404 	public final void parameterDeclarationList() throws RecognitionException, TokenStreamException {
7405 		
7406 		returnAST = null;
7407 		ASTPair currentAST = new ASTPair();
7408 		AST parameterDeclarationList_AST = null;
7409 		Token first = LT(1);
7410 		
7411 		{
7412 		switch ( LA(1)) {
7413 		case FINAL:
7414 		case LITERAL_def:
7415 		case IDENT:
7416 		case AT:
7417 		case LITERAL_void:
7418 		case LITERAL_boolean:
7419 		case LITERAL_byte:
7420 		case LITERAL_char:
7421 		case LITERAL_short:
7422 		case LITERAL_int:
7423 		case LITERAL_float:
7424 		case LITERAL_long:
7425 		case LITERAL_double:
7426 		case TRIPLE_DOT:
7427 		{
7428 			parameterDeclaration();
7429 			astFactory.addASTChild(currentAST, returnAST);
7430 			{
7431 			_loop256:
7432 			do {
7433 				if ((LA(1)==COMMA)) {
7434 					match(COMMA);
7435 					nls();
7436 					parameterDeclaration();
7437 					astFactory.addASTChild(currentAST, returnAST);
7438 				}
7439 				else {
7440 					break _loop256;
7441 				}
7442 				
7443 			} while (true);
7444 			}
7445 			break;
7446 		}
7447 		case RPAREN:
7448 		case CLOSABLE_BLOCK_OP:
7449 		case NLS:
7450 		{
7451 			break;
7452 		}
7453 		default:
7454 		{
7455 			throw new NoViableAltException(LT(1), getFilename());
7456 		}
7457 		}
7458 		}
7459 		if ( inputState.guessing==0 ) {
7460 			parameterDeclarationList_AST = (AST)currentAST.root;
7461 			parameterDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(PARAMETERS,"PARAMETERS",first,LT(1))).add(parameterDeclarationList_AST));
7462 			currentAST.root = parameterDeclarationList_AST;
7463 			currentAST.child = parameterDeclarationList_AST!=null &&parameterDeclarationList_AST.getFirstChild()!=null ?
7464 				parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST;
7465 			currentAST.advanceChildToEnd();
7466 		}
7467 		parameterDeclarationList_AST = (AST)currentAST.root;
7468 		returnAST = parameterDeclarationList_AST;
7469 	}
7470 	
7471 	public final void throwsClause() throws RecognitionException, TokenStreamException {
7472 		
7473 		returnAST = null;
7474 		ASTPair currentAST = new ASTPair();
7475 		AST throwsClause_AST = null;
7476 		
7477 		nls();
7478 		AST tmp178_AST = null;
7479 		tmp178_AST = astFactory.create(LT(1));
7480 		astFactory.makeASTRoot(currentAST, tmp178_AST);
7481 		match(LITERAL_throws);
7482 		nls();
7483 		identifier();
7484 		astFactory.addASTChild(currentAST, returnAST);
7485 		{
7486 		_loop252:
7487 		do {
7488 			if ((LA(1)==COMMA)) {
7489 				match(COMMA);
7490 				nls();
7491 				identifier();
7492 				astFactory.addASTChild(currentAST, returnAST);
7493 			}
7494 			else {
7495 				break _loop252;
7496 			}
7497 			
7498 		} while (true);
7499 		}
7500 		throwsClause_AST = (AST)currentAST.root;
7501 		returnAST = throwsClause_AST;
7502 	}
7503 	
7504 	public final void compoundStatement() throws RecognitionException, TokenStreamException {
7505 		
7506 		returnAST = null;
7507 		ASTPair currentAST = new ASTPair();
7508 		AST compoundStatement_AST = null;
7509 		
7510 		openBlock();
7511 		astFactory.addASTChild(currentAST, returnAST);
7512 		compoundStatement_AST = (AST)currentAST.root;
7513 		returnAST = compoundStatement_AST;
7514 	}
7515 	
7516 /** I've split out constructors separately; we could maybe integrate back into variableDefinitions
7517  *  later on if we maybe simplified 'def' to be a type declaration?
7518  */
7519 	public final void constructorDefinition(
7520 		AST mods
7521 	) throws RecognitionException, TokenStreamException {
7522 		
7523 		returnAST = null;
7524 		ASTPair currentAST = new ASTPair();
7525 		AST constructorDefinition_AST = null;
7526 		Token  id = null;
7527 		AST id_AST = null;
7528 		AST param_AST = null;
7529 		AST tc_AST = null;
7530 		AST cb_AST = null;
7531 		Token first = cloneToken(LT(1));
7532 		if (mods != null) {
7533 		first.setLine(mods.getLine());
7534 		first.setColumn(mods.getColumn());
7535 		}
7536 		
7537 		id = LT(1);
7538 		id_AST = astFactory.create(id);
7539 		astFactory.addASTChild(currentAST, id_AST);
7540 		match(IDENT);
7541 		match(LPAREN);
7542 		parameterDeclarationList();
7543 		param_AST = (AST)returnAST;
7544 		match(RPAREN);
7545 		{
7546 		boolean synPredMatched241 = false;
7547 		if (((LA(1)==LITERAL_throws||LA(1)==NLS) && (_tokenSet_28.member(LA(2))))) {
7548 			int _m241 = mark();
7549 			synPredMatched241 = true;
7550 			inputState.guessing++;
7551 			try {
7552 				{
7553 				nls();
7554 				match(LITERAL_throws);
7555 				}
7556 			}
7557 			catch (RecognitionException pe) {
7558 				synPredMatched241 = false;
7559 			}
7560 			rewind(_m241);
7561 inputState.guessing--;
7562 		}
7563 		if ( synPredMatched241 ) {
7564 			throwsClause();
7565 			tc_AST = (AST)returnAST;
7566 		}
7567 previous bug bug overview next bug   		else if ((LA(1)==LCURLY||LA(1)==NLS) && (_tokenSet_65.member(LA(2)))) {  HEALTH4J >>  :  EmptyIfStmt 
7568 		}
7569 		else {
7570 			throw new NoViableAltException(LT(1), getFilename());
7571 		}
7572 		
7573 		}
7574 		nlsWarn();
7575 		if ( inputState.guessing==0 ) {
7576 			isConstructorIdent(id);
7577 		}
7578 		constructorBody();
7579 		cb_AST = (AST)returnAST;
7580 		if ( inputState.guessing==0 ) {
7581 			constructorDefinition_AST = (AST)currentAST.root;
7582 			constructorDefinition_AST =  (AST)astFactory.make( (new ASTArray(5)).add(create(CTOR_IDENT,"CTOR_IDENT",first,LT(1))).add(mods).add(param_AST).add(tc_AST).add(cb_AST));
7583 			
7584 			currentAST.root = constructorDefinition_AST;
7585 			currentAST.child = constructorDefinition_AST!=null &&constructorDefinition_AST.getFirstChild()!=null ?
7586 				constructorDefinition_AST.getFirstChild() : constructorDefinition_AST;
7587 			currentAST.advanceChildToEnd();
7588 		}
7589 		constructorDefinition_AST = (AST)currentAST.root;
7590 		returnAST = constructorDefinition_AST;
7591 	}
7592 	
7593 	public final void multipleAssignmentDeclarationStart() throws RecognitionException, TokenStreamException {
7594 		
7595 		returnAST = null;
7596 		ASTPair currentAST = new ASTPair();
7597 		AST multipleAssignmentDeclarationStart_AST = null;
7598 		
7599 		{
7600 		_loop221:
7601 		do {
7602 			switch ( LA(1)) {
7603 			case FINAL:
7604 			case ABSTRACT:
7605