This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository nuiton-config. See https://gitlab.nuiton.org/nuiton/nuiton-config.git commit f5704d11c6204d0be6e5dc5f05318aaa157994dd Author: Tony CHEMIT <chemit@codelutin.com> Date: Sat Oct 1 16:47:23 2016 +0200 Introduce a model description file format and use it to generate all config classes (See #4053) --- nuiton-config-example/pom.xml | 104 +- .../src/main/config/NuitonConfigExample.yml | 39 + .../nuiton/config/example/NuitonConfigExample.java | 18 +- .../example/NuitonConfigExampleConfigOption.java | 156 - .../i18n/nuiton-config-example_en_GB.properties | 1 - .../i18n/nuiton-config-example_fr_FR.properties | 1 - nuiton-config-example/src/site/apt/index.apt | 45 - nuiton-config-example/src/site/apt/index.apt.vm | 207 + nuiton-config-maven-plugin/pom.xml | 23 +- .../org/nuiton/config/plugin/GenerateMojo.java | 313 +- .../org/nuiton/config/plugin/ReportRenderer.java | 2 +- .../nuiton/config/plugin/model/ActionModel.java | 51 +- .../nuiton/config/plugin/model/ConfigModel.java | 52 +- .../config/plugin/model/ConfigModelReader.java | 67 + .../nuiton/config/plugin/model/OptionModel.java | 185 + .../plugin/parser/java/Java8BaseVisitor.java | 2407 --- .../config/plugin/parser/java/Java8Lexer.java | 611 - .../config/plugin/parser/java/Java8Parser.java | 19733 ------------------- .../config/plugin/parser/java/Java8Visitor.java | 1932 -- .../templates/ApplicationConfigTransformer.java | 320 +- .../ApplicationConfigTransformerConfig.java | 33 +- .../plugin/parser/yml/ConfigModelReaderTest.java | 94 + .../src/test/resources/NuitonConfigExample.yml | 39 + pom.xml | 7 +- 24 files changed, 1163 insertions(+), 25277 deletions(-) diff --git a/nuiton-config-example/pom.xml b/nuiton-config-example/pom.xml index 1a3ed52..02f2d1b 100644 --- a/nuiton-config-example/pom.xml +++ b/nuiton-config-example/pom.xml @@ -19,31 +19,46 @@ <!-- Post Release configuration --> <skipPostRelease>false</skipPostRelease> + <nuitonConfigVersion>${project.version}</nuitonConfigVersion> </properties> <dependencies> <dependency> - <groupId>${project.groupId}</groupId> + <groupId>org.nuiton</groupId> <artifactId>nuiton-config</artifactId> - <version>${project.version}</version> - </dependency> - <dependency> - <groupId>org.nuiton.i18n</groupId> - <artifactId>nuiton-i18n</artifactId> + <version>${nuitonConfigVersion}</version> </dependency> </dependencies> <build> + <pluginManagement> + <plugins> + <plugin> + <artifactId>maven-jar-plugin</artifactId> + <configuration> + <archive> + <manifest> + <useUniqueVersions>false</useUniqueVersions> + <addClasspath>false</addClasspath> + <classpathPrefix/> + <mainClass>org.nuiton.config.example.NuitonConfigExample</mainClass> + </manifest> + </archive> + </configuration> + </plugin> + </plugins> + </pluginManagement> + <plugins> <plugin> - <groupId>${project.groupId}</groupId> + <groupId>org.nuiton</groupId> <artifactId>nuiton-config-maven-plugin</artifactId> - <version>${project.version}</version> + <version>${nuitonConfigVersion}</version> <executions> <execution> <phase>generate-sources</phase> @@ -54,59 +69,60 @@ </executions> </plugin> - <plugin> - <groupId>org.nuiton.i18n</groupId> - <artifactId>i18n-maven-plugin</artifactId> - <executions> - <execution> - <phase>generate-sources</phase> - <goals> - <goal>parserJava</goal> - <goal>gen</goal> - </goals> - <configuration> - <entries> - <entry> - <basedir>${project.build.directory}/generated-sources/java</basedir> - </entry> - </entries> - </configuration> - </execution> - </executions> - </plugin> - </plugins> </build> + <reporting> + <plugins> + <plugin> + <groupId>org.nuiton</groupId> + <artifactId>nuiton-config-maven-plugin</artifactId> + <version>${nuitonConfigVersion}</version> + <reportSets> + <reportSet> + <reports> + <report>report</report> + </reports> + </reportSet> + </reportSets> + </plugin> + </plugins> + </reporting> + <profiles> <profile> - <id>reporting</id> + <id>assembly-profile</id> <activation> <property> <name>performRelease</name> <value>true</value> </property> </activation> - - <reporting> + <build> + <defaultGoal>package</defaultGoal> <plugins> <plugin> - <groupId>${project.groupId}</groupId> - <artifactId>nuiton-config-maven-plugin</artifactId> - <version>${project.version}</version> - <reportSets> - <reportSet> - <reports> - <report>report</report> - </reports> - </reportSet> - </reportSets> + <artifactId>maven-assembly-plugin</artifactId> + <executions> + <execution> + <id>create-assemblies</id> + <phase>package</phase> + <goals> + <goal>single</goal> + </goals> + </execution> + </executions> + <configuration> + <attach>true</attach> + <descriptorRefs> + <descriptorRef>full</descriptorRef> + </descriptorRefs> + </configuration> </plugin> </plugins> - </reporting> - + </build> </profile> </profiles> diff --git a/nuiton-config-example/src/main/config/NuitonConfigExample.yml b/nuiton-config-example/src/main/config/NuitonConfigExample.yml new file mode 100644 index 0000000..9d74f30 --- /dev/null +++ b/nuiton-config-example/src/main/config/NuitonConfigExample.yml @@ -0,0 +1,39 @@ +description: Exemple de configuration +options: + - !option + name: firstName + key: identity.firstName + type: string + description: Prénom de l'utilisateur + defaultValue: Joshua + - !option + name: lastName + key: identity.lastName + type: string + description: Nom de l'utilisateur + defaultValue: Bloch + - !option + name: email + key: identity.email + type: string + description: Courriel de l'utilisateur + - !option + name: twitter + key: identity.twitter + type: string + description: Compte Twitter de l'utilisateur + defaultValue: jbloch + - !option + name: age + key: identity.age + type: int + description: age de l'utilisateur + defaultValue: 56 +actions: + - !action + name: help + description: Pour afficher l'aide + action: org.nuiton.config.example.NuitonConfigExample#help + aliases: + - "-h" + - "--help" \ No newline at end of file diff --git a/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExample.java b/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExample.java index 4835f3c..d646d59 100644 --- a/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExample.java +++ b/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExample.java @@ -33,11 +33,19 @@ public class NuitonConfigExample { NuitonConfigExampleConfig config = new NuitonConfigExampleConfig(); - config.get().parse(args); - - System.out.println("Configuration file name : " + config.getConfigFile()); - System.out.println("Application data directory : " + config.getDataDirectory()); - System.out.println("Application db directory : " + config.getDbDirectory()); + config.get().parse( + "--option", "identity.lastName", "Bloch", + "--option", "identity.firstName", "Joshua" + ); + + config.setAge(55); + config.setTwitter("joshbloch"); + + System.out.println("Last name : " + config.getLastName()); + System.out.println("First name : " + config.getFirstName()); + System.out.println("Email : " + config.getEmail()); + System.out.println("Twitter : " + config.getTwitter()); + System.out.println("Age : " + config.getAge()); } diff --git a/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExampleConfigOption.java b/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExampleConfigOption.java deleted file mode 100644 index 6c45a7e..0000000 --- a/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExampleConfigOption.java +++ /dev/null @@ -1,156 +0,0 @@ -package org.nuiton.config.example; - -/*- - * #%L - * Nuiton Config :: Example - * %% - * Copyright (C) 2016 Code Lutin, Tony Chemit - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ - -import org.nuiton.config.ConfigOptionDef; - -import java.io.File; - -public enum NuitonConfigExampleConfigOption implements ConfigOptionDef { - - /** - * le nom du fichier de configuration (sans le prefix .) - */ - CONFIG_FILE( - String.class, - "config.file", - "Nom du fichier de configuration", - "application", - true, - true - ), - - /** - * le repertoire de stoquage des données - */ - DATA_DIRECTORY( - File.class, - "data.directory", - "Répertoire de données", - "${user.home}/.application", - true, - true - ), - - /** - * le repertoire de stoquage de la base locale - */ - DB_DIRECTORY( - File.class, - "db.directory", - "Répertoire de la base de données", - "${data.directory}/db", - true, - true - ); - - /** - * Clef qui représente l'option (c'est celle enregistrée dans le fichier de configuration). - */ - protected final String key; - - /** - * Clef i18n de description de l'option - */ - protected final String description; - - /** - * Type de l'option - */ - protected final Class<?> type; - - /** - * Valeur par défaut de l'option - */ - protected String defaultValue; - - /** - * Drapeau pour savoir si on ne doit pas sauvegarder cette option - */ - protected boolean _transient; - - /** - * Drapeau pour savoir si l'option est modifiable - */ - protected boolean _final; - - NuitonConfigExampleConfigOption(Class<?> type, - String key, - String description, - String defaultValue, - boolean _transient, - boolean _final) { - this.key = key; - this.description = description; - this.defaultValue = defaultValue; - this.type = type; - this._final = _final; - this._transient = _transient; - } - - @Override - public boolean isFinal() { - return _final; - } - - @Override - public boolean isTransient() { - return _transient; - } - - @Override - public String getDefaultValue() { - return defaultValue; - } - - @Override - public String getDescription() { - return description; - } - - @Override - public String getKey() { - return key; - } - - @Override - public Class<?> getType() { - return type; - } - - @Override - public void setDefaultValue(String defaultValue) { - this.defaultValue = defaultValue; - } - - @Override - public void setTransient(boolean _transient) { - this._transient = _transient; - } - - @Override - public void setFinal(boolean _final) { - this._final = _final; - } - -} diff --git a/nuiton-config-example/src/main/resources/i18n/nuiton-config-example_en_GB.properties b/nuiton-config-example/src/main/resources/i18n/nuiton-config-example_en_GB.properties deleted file mode 100644 index 874cc75..0000000 --- a/nuiton-config-example/src/main/resources/i18n/nuiton-config-example_en_GB.properties +++ /dev/null @@ -1 +0,0 @@ -NuitonConfigExampleConfig.description=Example configuration diff --git a/nuiton-config-example/src/main/resources/i18n/nuiton-config-example_fr_FR.properties b/nuiton-config-example/src/main/resources/i18n/nuiton-config-example_fr_FR.properties deleted file mode 100644 index a7eb816..0000000 --- a/nuiton-config-example/src/main/resources/i18n/nuiton-config-example_fr_FR.properties +++ /dev/null @@ -1 +0,0 @@ -NuitonConfigExampleConfig.description=Configuration d'exemple diff --git a/nuiton-config-example/src/site/apt/index.apt b/nuiton-config-example/src/site/apt/index.apt deleted file mode 100644 index d29c8c0..0000000 --- a/nuiton-config-example/src/site/apt/index.apt +++ /dev/null @@ -1,45 +0,0 @@ -~~~ -~~ #%L -~~ Nuiton Config :: Example -~~ %% -~~ Copyright (C) 2016 Code Lutin, Tony Chemit -~~ %% -~~ This program is free software: you can redistribute it and/or modify -~~ it under the terms of the GNU Lesser General Public License as -~~ published by the Free Software Foundation, either version 3 of the -~~ License, or (at your option) any later version. -~~ -~~ This program is distributed in the hope that it will be useful, -~~ but WITHOUT ANY WARRANTY; without even the implied warranty of -~~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -~~ GNU General Lesser Public License for more details. -~~ -~~ You should have received a copy of the GNU General Lesser Public -~~ License along with this program. If not, see -~~ <http://www.gnu.org/licenses/lgpl-3.0.html>. -~~ #L% -~~~ - ---- - Nuiton Config Exemple - ---- - ---- - 2016-09-30 - ---- - -Utilisation - - 3 étapes pour utiliser <<nuiton-config>> : - -* Décrire les options de la configuration - - Écrire la classe qui définit les options de configuration. - -* Générer la classe de configuration - - Utiliser le mojo <<generate>> pour générer la classe de configuration java <org.nuiton.config.application.MyApplicationConfig> - -* Générer la documentation de la configuration - - Utiliser le mojo de report <<report>> ou <<aggregate-report>> pour générer la documentations des configurations détectées. - -TODO Pointer sur les fichiers sources et générés. diff --git a/nuiton-config-example/src/site/apt/index.apt.vm b/nuiton-config-example/src/site/apt/index.apt.vm new file mode 100644 index 0000000..be82fd8 --- /dev/null +++ b/nuiton-config-example/src/site/apt/index.apt.vm @@ -0,0 +1,207 @@ +~~~ +~~ #%L +~~ Nuiton Config :: Example +~~ %% +~~ Copyright (C) 2016 Code Lutin, Tony Chemit +~~ %% +~~ This program is free software: you can redistribute it and/or modify +~~ it under the terms of the GNU Lesser General Public License as +~~ published by the Free Software Foundation, either version 3 of the +~~ License, or (at your option) any later version. +~~ +~~ This program is distributed in the hope that it will be useful, +~~ but WITHOUT ANY WARRANTY; without even the implied warranty of +~~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +~~ GNU General Lesser Public License for more details. +~~ +~~ You should have received a copy of the GNU General Lesser Public +~~ License along with this program. If not, see +~~ <http://www.gnu.org/licenses/lgpl-3.0.html>. +~~ #L% +~~~ + ---- + Nuiton Config Exemple + ---- + ---- + 2016-09-30 + ---- + +Utilisation + + Ce module est un exemple d'utilisation de <<nuiton-config>>. + + Le principe est simple + + * Décrire la configuration dans un fichier au format simple ; + + * Générer via le plugin maven le code java à partir de la description ; + + * Utiliser la classe java de configuration qui a été générée ; + + * Documenter votre configuration via le plugin de report. + + [] + + Vous pouvez télécharger les sources du projet {{{https://nexus.nuiton.org/nexus/service/local/artifact/maven/redirect?g=public&g=org.nuiton&a=nuiton-config-example&v=${project.version}&e=zip&c=full}ici}}. + + Dans cet exemple, nous utilisations toutes les valeurs par défaut fournies par le plugin (ZéroConf). + + Voici le GAV du projet + ++------------------------------------------------ + <groupId>${project.groupId}</groupId> + <artifactId>${project.artifactId}</artifactId> + <version>${project.version}</version> ++------------------------------------------------ + + En utilisant les conventions du projet, la classe de configuration se nommera <<org.nuiton.config.example.NuitonConfigExampleConfig>>. + +* Décrire les options et les actions de la configuration + + Dans notre exemple, nous avons 4 options dans la configuration : + + * <<lastName>> le nom de l'utilisateur + + * <<firstName>> le prénom de passe de l'utilisateur + + * <<email>> le courriel de l'utilisateur + + * <<twitter>> le compte twitter de l'utilisateur + + * <<age>> l'age de l'utilisateur + + [] + + Nous avons aussi défini une action : + + * <<help>> pour afficher l'aide + + [] + + Voici le fichier de description de cette configuration : + ++------------------------------------------------ +description: Exemple de configuration +options: + - !option + name: firstName + key: identity.firstName + type: string + description: Prénom de l'utilisateur + defaultValue: Joshua + - !option + name: lastName + key: identity.lastName + type: string + description: Nom de l'utilisateur + defaultValue: Bloch + - !option + name: email + key: identity.email + type: string + description: Courriel de l'utilisateur + - !option + name: twitter + key: identity.twitter + type: string + description: Compte Twitter de l'utilisateur + defaultValue: jbloch + - !option + name: age + key: identity.age + type: int + description: age de l'utilisateur + defaultValue: 56 +actions: + - !action + name: help + description: Pour afficher l'aide + action: org.nuiton.config.example.NuitonConfigExample#help + aliases: + - "-h" + - "--help" ++------------------------------------------------ + + +* Générer les classes de configuration + + Utiliser le mojo <<generate>> pour générer les classes. + ++------------------------------------------------ + <plugin> + <groupId>org.nuiton</groupId> + <artifactId>nuiton-config-maven-plugin</artifactId> + <version>${project.version}</version> + <executions> + <execution> + <goals> + <goal>generate</goal> + </goals> + </execution> + </executions> + </plugin> ++------------------------------------------------ + + Cela va générer les classes suivantes : + ++------------------------------------------------ +target +└── generated-sources + └── java + ├── META-INF + │ └── services + │ └── org.nuiton.config.ApplicationConfigProvider (1) + └── org + └── nuiton + └── config + └── example + ├── GeneratedNuitonConfigExampleConfig.java (2) + ├── GeneratedNuitonConfigExampleConfigProvider.java (3) + ├── NuitonConfigExampleConfig.java (4) + ├── NuitonConfigExampleConfigAction.java (5) + ├── NuitonConfigExampleConfigOption.java (6) + └── NuitonConfigExampleConfigProvider.java (7) + ++------------------------------------------------ + + * (1) fichier qui enregistre (en utilisant le mécanisme ServiceLoader), le provider de configuration généré + + * (2) classe abstraite de configuration + + * (3) classe abstraite de provider + + * <<(4) classe de configuration prête à l'emploi dans votre application>> + + * (5) classe qui décrit les actions + + * (6) classe qui décrit les options + + * (5) provider de configuration prêt à l'emploi (il sert pour la génération de la documentation notamment) + + [] + + <« Et Voila !»>, vous pouvez utiliser la classe de configuration qui est prête à l'emploi. + + Retrouver le code source de toues les classes du projet ({{{./xref/index.html}ici}}). + +* Générer la documentation de la configuration + + Utiliser le mojo de report <<report>> ou <<aggregate-report>> pour générer la documentation sur les configurations + détectées via les providers. + ++------------------------------------------------ + <plugin> + <groupId>${project.groupId}</groupId> + <artifactId>nuiton-config-maven-plugin</artifactId> + <version>${project.version}</version> + <reportSets> + <reportSet> + <reports> + <report>report</report> + </reports> + </reportSet> + </reportSets> + </plugin> ++------------------------------------------------ + + Retrouver le rapport généré ({{{./config-report.html}ici}}). diff --git a/nuiton-config-maven-plugin/pom.xml b/nuiton-config-maven-plugin/pom.xml index 8158c6e..4e99ad1 100644 --- a/nuiton-config-maven-plugin/pom.xml +++ b/nuiton-config-maven-plugin/pom.xml @@ -63,15 +63,6 @@ </dependency> <dependency> - <groupId>com.tunnelvisionlabs</groupId> - <artifactId>antlr4-runtime</artifactId> - </dependency> - <!--dependency> - <groupId>com.tunnelvisionlabs</groupId> - <artifactId>antlr4-annotations</artifactId> - </dependency--> - - <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> </dependency> @@ -87,11 +78,6 @@ </dependency> <dependency> - <groupId>commons-io</groupId> - <artifactId>commons-io</artifactId> - </dependency> - - <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> </dependency> @@ -102,6 +88,11 @@ </dependency> <dependency> + <groupId>com.esotericsoftware.yamlbeans</groupId> + <artifactId>yamlbeans</artifactId> + </dependency> + + <dependency> <groupId>org.apache.maven</groupId> <artifactId>maven-core</artifactId> </dependency> @@ -173,6 +164,10 @@ <scope>runtime</scope> </dependency> + <dependency> + <groupId>junit</groupId> + <artifactId>junit</artifactId> + </dependency> </dependencies> <build> diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/GenerateMojo.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/GenerateMojo.java index 54b0686..af5a305 100644 --- a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/GenerateMojo.java +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/GenerateMojo.java @@ -25,10 +25,6 @@ package org.nuiton.config.plugin; import com.google.common.base.Joiner; import com.google.common.collect.Iterables; import com.google.common.io.Files; -import org.antlr.v4.runtime.ANTLRInputStream; -import org.antlr.v4.runtime.CommonTokenStream; -import org.antlr.v4.runtime.TokenStream; -import org.apache.commons.io.FileUtils; import org.apache.commons.lang3.StringUtils; import org.apache.maven.model.Resource; import org.apache.maven.plugin.MojoExecutionException; @@ -38,35 +34,22 @@ import org.apache.maven.plugins.annotations.Parameter; import org.apache.maven.plugins.annotations.ResolutionScope; import org.apache.maven.project.MavenProject; import org.nuiton.config.ApplicationConfigProvider; -import org.nuiton.config.plugin.parser.java.Java8BaseVisitor; -import org.nuiton.config.plugin.parser.java.Java8Lexer; -import org.nuiton.config.plugin.parser.java.Java8Parser; +import org.nuiton.config.plugin.model.ConfigModel; +import org.nuiton.config.plugin.model.ConfigModelReader; import org.nuiton.config.plugin.templates.ApplicationConfigTransformer; +import org.nuiton.config.plugin.templates.ApplicationConfigTransformerConfig; import org.nuiton.eugene.DefaultTemplateConfiguration; import org.nuiton.eugene.Template; -import org.nuiton.eugene.java.JavaGeneratorUtil; -import org.nuiton.eugene.models.object.xml.ObjectModelAttributeImpl; -import org.nuiton.eugene.models.object.xml.ObjectModelClassImpl; import org.nuiton.eugene.models.object.xml.ObjectModelImpl; import org.nuiton.plugin.AbstractPlugin; import org.nuiton.plugin.PluginHelper; import org.nuiton.plugin.PluginWithEncoding; -import org.nuiton.version.Version; -import javax.swing.KeyStroke; -import java.awt.Color; import java.io.File; -import java.net.URL; -import java.sql.Time; -import java.sql.Timestamp; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; -import java.util.Date; -import java.util.LinkedHashMap; import java.util.List; -import java.util.Locale; -import java.util.Map; import java.util.Properties; import static java.util.Arrays.asList; @@ -80,7 +63,7 @@ import static java.util.Arrays.asList; * @since 3.0 */ @Mojo(name = "generate", defaultPhase = LifecyclePhase.GENERATE_SOURCES, requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME) -public class GenerateMojo extends AbstractPlugin implements PluginWithEncoding { +public class GenerateMojo extends AbstractPlugin implements PluginWithEncoding, ApplicationConfigTransformerConfig { /** * To set the package fully qualified name of the generated class. @@ -109,26 +92,51 @@ public class GenerateMojo extends AbstractPlugin implements PluginWithEncoding { private String modelName; /** - * The fully qualified name of the enum class of options to scan to generate the configuration java files. + * The simple name of the options class. * <p> - * By default, will use groupId.artifactId (with {@code -} replaced by {@code .}) plus {@code .modelNameConfigOption}. + * By default, will use {@code config.modelName + ConfigOption}. * </p> - * Example: {@code org.nuiton:nuiton-config-example} gives {@code org.nuiton.config.example.NuitonConfigExampleConfigOption} */ @Parameter(property = "config.optionsClassName") private String optionsClassName; /** - * The fully qualified name of the enum class of actions to scan to generate the configuration java files. + * The simple name of the actions class. * <p> - * By default, will use groupId.artifactId (with {@code -} replaced by {@code .}) plus {@code .config.modelNameAction}. + * By default, will use {@code config.modelName + ConfigAction}. * </p> - * Example: {@code org.nuiton:nuiton-config-example} gives {@code org.nuiton.config.example.NuitonConfigExampleConfigAction} */ @Parameter(property = "config.actionsClassName") private String actionsClassName; /** + * Pour générer le provider de configuration. + */ + @Parameter(property = "config.generateProvider", defaultValue = "true") + private boolean generateProvider; + + /** + * Pour utiliser l'API de nuiton-i18n pour traduire les descriptions dans le code généré. + */ + @Parameter(property = "config.useNuitonI18n") + private boolean useNuitonI18n; + + /** + * The path of model file. + * + * <p>Default value is </p> + * <pre>config.sourceDirectory/config.modelName.yml</pre> + */ + @Parameter(property = "config.modelFile") + private File modelFile; + + /** + * The source directory where to scan model file. + */ + @Parameter(property = "config.modelDirectory", defaultValue = "${basedir}/src/main/config", required = true) + private File modelDirectory; + + /** * The source directory where to scan options java file. */ @Parameter(property = "config.sourceDirectory", defaultValue = "${basedir}/src/main/java", required = true) @@ -141,12 +149,6 @@ public class GenerateMojo extends AbstractPlugin implements PluginWithEncoding { private File outputdirectory; /** - * Pour générer le provider de configuration. - */ - @Parameter(property = "config.generateProvider", defaultValue = "true") - private boolean generateProvider; - - /** * Pour activer le mode verbeux. */ @Parameter(property = "config.verbose", defaultValue = "${maven.verbose}") @@ -167,78 +169,60 @@ public class GenerateMojo extends AbstractPlugin implements PluginWithEncoding { @Parameter(defaultValue = "${project}", readonly = true) private MavenProject project; - private ObjectModelImpl model; + private ObjectModelImpl objectModel; private ApplicationConfigTransformer template; private String configClassName; + private String configProviderClassName; + private ConfigModel configModel; @Override protected void init() throws Exception { - if (packageName == null) { - - List<String> groupIdPaths = new ArrayList<>(asList(getProject().getGroupId().split("\\."))); - - List<String> artifactIdPaths = new ArrayList<>(Arrays.asList(getProject().getArtifactId().replaceAll("-", ".").split("\\."))); - if (Iterables.getLast(groupIdPaths).equals(Iterables.getFirst(artifactIdPaths, null))) { - artifactIdPaths.remove(0); - } - groupIdPaths.addAll(artifactIdPaths); - - packageName = Joiner.on(".").join(groupIdPaths); - getLog().info("Use package name: " + packageName); - } - if (modelName == null) { List<String> artifactIdPaths = new ArrayList<>(); for (String artifactIdPath : Arrays.asList(getProject().getArtifactId().replaceAll("-", ".").split("\\."))) { artifactIdPaths.add(StringUtils.capitalize(artifactIdPath)); } modelName = Joiner.on("").join(artifactIdPaths); - getLog().info("Use model name: " + modelName); + getLog().info("Use objectModel name: " + modelName); } - String prefix = "Config"; - - if (optionsClassName == null) { - - optionsClassName = packageName + "." + modelName + prefix + "Option"; - File file = PluginHelper.getFile(sourceDirectory, optionsClassName.split("\\.")); - File javaFile = new File(file.getParentFile(), file.getName() + ".java"); + if (modelFile==null) { + modelFile = new File(modelDirectory, modelName + ".yml"); + } - if (!javaFile.exists()) { + if (!modelFile.exists()) { - prefix = "Configuration"; + throw new MojoExecutionException("No model file found at: " + modelFile); + } - optionsClassName = packageName + "." + modelName + prefix + "Option"; + if (packageName == null) { - file = PluginHelper.getFile(sourceDirectory, optionsClassName.split("\\.")); - javaFile = new File(file.getParentFile(), file.getName() + ".java"); + List<String> groupIdPaths = new ArrayList<>(asList(getProject().getGroupId().split("\\."))); - if (!javaFile.exists()) { - throw new MojoExecutionException("Can't find option file at: " + javaFile); - } + List<String> artifactIdPaths = new ArrayList<>(Arrays.asList(getProject().getArtifactId().replaceAll("-", ".").split("\\."))); + if (Iterables.getLast(groupIdPaths).equals(Iterables.getFirst(artifactIdPaths, null))) { + artifactIdPaths.remove(0); } - getLog().info("Detected configuration options class: " + optionsClassName); + groupIdPaths.addAll(artifactIdPaths); + packageName = Joiner.on(".").join(groupIdPaths); + getLog().info("Use package name: " + packageName); } - if (actionsClassName == null) { - - actionsClassName = packageName + "." + modelName + prefix + "Action"; + if (optionsClassName == null) { - File file = PluginHelper.getFile(sourceDirectory, actionsClassName.split("\\.")); - File javaFile = new File(file.getParentFile(), file.getName() + ".java"); + optionsClassName = modelName + "ConfigOption"; + getLog().info("Configuration options class: " + optionsClassName); - if (javaFile.exists()) { + } - getLog().info("Detected configuration actions class: " + actionsClassName); - } else { + if (actionsClassName == null) { - // won't be used - actionsClassName = null; - } + actionsClassName = modelName + "ConfigAction"; + getLog().info("Configuration actions class: " + actionsClassName); } @@ -246,55 +230,27 @@ public class GenerateMojo extends AbstractPlugin implements PluginWithEncoding { // get options - model = new ObjectModelImpl(); - model.setName(modelName); + objectModel = new ObjectModelImpl(); + objectModel.setName(modelName); - configClassName = modelName + prefix; + configClassName = modelName + "Config"; getLog().info("Config class name: " + configClassName); - File file = PluginHelper.getFile(sourceDirectory, optionsClassName.split("\\.")); - File javaFile = new File(file.getParentFile(), file.getName() + ".java"); - - String content = FileUtils.readFileToString(javaFile, encoding); - TokenStream tokenStream = new CommonTokenStream(new Java8Lexer(new ANTLRInputStream(content))); - Java8Parser parser = new Java8Parser(tokenStream); - - - // see http://stackoverflow.com/a/32918434/2038100 - //parser.setErrorHandler(new BailErrorStrategy()); - //parser.getInterpreter().setPredictionMode(PredictionMode.SLL); - //parser.getInterpreter().tail_call_preserves_sll = false; - parser.getInterpreter().enable_global_context_dfa = true; - - JavaParserVisitor visitor = new JavaParserVisitor(loader, javaFile); - parser.compilationUnit().accept(visitor); - - Map<String, String> names = visitor.getNames(); - - ObjectModelClassImpl aClass = new ObjectModelClassImpl(); - aClass.setName(configClassName); - aClass.setPackage(packageName); - model.addClass(aClass); - - for (Map.Entry<String, String> entry : names.entrySet()) { - ObjectModelAttributeImpl attribute = new ObjectModelAttributeImpl(); - attribute.setName(JavaGeneratorUtil.convertConstantNameToVariableName(entry.getKey())); - attribute.setType(entry.getValue()); - aClass.addAttribute(attribute); + if (generateProvider) { + configProviderClassName = configClassName + "Provider"; + getLog().info("Config provider class name: " + configClassName); } + configModel = ConfigModelReader.read(modelFile.toPath()); + Properties templateProperties = new Properties(); templateProperties.put(Template.PROP_ENCODING, getEncoding()); templateProperties.put(Template.PROP_VERBOSE, verbose); templateProperties.put(Template.PROP_OVERWRITE, true); templateProperties.put(Template.PROP_CLASS_LOADER, loader); - templateProperties.put(ApplicationConfigTransformer.PROP_GENERATE_PROVIDER, generateProvider + ""); - templateProperties.put(ApplicationConfigTransformer.PROP_OPTION_CLASS_NAME, optionsClassName); - if (actionsClassName != null) { - templateProperties.put(ApplicationConfigTransformer.PROP_ACTION_CLASS_NAME, actionsClassName); - } + templateProperties.put(ApplicationConfigTransformer.PROP_CONFIG, this); template = new ApplicationConfigTransformer(); template.setConfiguration(new DefaultTemplateConfiguration(templateProperties)); @@ -312,7 +268,7 @@ public class GenerateMojo extends AbstractPlugin implements PluginWithEncoding { getLog().info("Generate file(s) to: " + outputdirectory); - template.applyTemplate(model, outputdirectory); + template.applyTemplate(objectModel, outputdirectory); if (generateProvider) { @@ -358,107 +314,48 @@ public class GenerateMojo extends AbstractPlugin implements PluginWithEncoding { this.project = project; } - private class JavaParserVisitor extends Java8BaseVisitor<Void> { - - private final Map<String, String> names; + @Override + public String getPackageName() { + return packageName; + } - private final ClassLoader loader; - final File file; + @Override + public String getModelName() { + return modelName; + } - private JavaParserVisitor(ClassLoader loader, File file) { - this.loader = loader; - this.file = file; - this.names = new LinkedHashMap<>(); - } + @Override + public String getOptionsClassName() { + return optionsClassName; + } - Map<String, String> getNames() { - return names; - } + @Override + public String getActionsClassName() { + return actionsClassName; + } - String name; - boolean first; + @Override + public boolean isGenerateProvider() { + return generateProvider; + } - @Override - public Void visitEnumConstant(Java8Parser.EnumConstantContext ctx) { - name = ctx.getChild(0).getText(); - first = false; - return super.visitEnumConstant(ctx); - } + @Override + public String getConfigProviderClassName() { + return configProviderClassName; + } - @Override - public Void visitArgumentList(Java8Parser.ArgumentListContext ctx) { - if (!first) { - - String type = StringUtils.removeEnd(ctx.getChild(0).getText(), ".class"); - switch (type) { - case "File": - type = File.class.getName(); - break; - case "Color": - type = Color.class.getName(); - break; - case "KeyStroke": - type = KeyStroke.class.getName(); - break; - case "URL": - type = URL.class.getName(); - break; - case "Class": - type = Class.class.getName(); - break; - case "Date": - type = Date.class.getName(); - break; - case "Time": - type = Time.class.getName(); - break; - case "Timestamp": - type = Timestamp.class.getName(); - break; - case "Locale": - type = Locale.class.getName(); - break; - case "Version": - type = Version.class.getName(); - break; - case "String": - case "int": - case "Integer": - case "long": - case "Long": - case "float": - case "Float": - case "boolean": - case "Boolean": - case "byte": - case "Byte": - case "char": - case "Character": - case "double": - case "Double": - break; - default: - try { - loader.loadClass(type); - } catch (ClassNotFoundException e) { - - // try to see if class found in source path - - File sourceFile = PluginHelper.getFile(sourceDirectory, type.split("\\.")); - sourceFile = new File(sourceFile.getParentFile(), sourceFile.getName() + ".java"); - if (!sourceFile.exists()) { - - throw new IllegalStateException("Can't find real type of " + type + " for option: " + name + ", please use the fully qualified name in code"); - } - } - } - - names.put(name, type); - first = true; - } - return super.visitArgumentList(ctx); - } + @Override + public String getConfigClassName() { + return configClassName; + } + @Override + public ConfigModel getConfigModel() { + return configModel; } + @Override + public boolean isUseNuitonI18n() { + return useNuitonI18n; + } } diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/ReportRenderer.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/ReportRenderer.java index 9ddae92..cfa1476 100644 --- a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/ReportRenderer.java +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/ReportRenderer.java @@ -117,7 +117,7 @@ class ReportRenderer extends AbstractMavenReportRenderer { sink.paragraph_(); sink.paragraph(); - sink.link("http://doc.nuiton.org/nuiton-config/index.html"); + sink.link("http://nuiton-config.nuiton.org/v/latest/index.html"); sink.text(getText("report.overview.more.information")); sink.link_(); sink.paragraph_(); diff --git a/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExampleConfigAction.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/ActionModel.java similarity index 64% copy from nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExampleConfigAction.java copy to nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/ActionModel.java index 8f939a9..26dbaed 100644 --- a/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExampleConfigAction.java +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/ActionModel.java @@ -1,10 +1,10 @@ -package org.nuiton.config.example; +package org.nuiton.config.plugin.model; /*- * #%L - * Nuiton Config :: Example + * Nuiton Config :: Maven plugin * %% - * Copyright (C) 2016 CodeLutin + * Copyright (C) 2016 Code Lutin, Tony Chemit * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as @@ -25,44 +25,49 @@ package org.nuiton.config.example; import org.nuiton.config.ConfigActionDef; /** - * Les actions appellables en ligne de commande. + * Created on 01/10/16. * * @author Tony Chemit - chemit@codelutin.com + * @since 3.0 */ -public enum NuitonConfigExampleConfigAction implements ConfigActionDef { +public class ActionModel implements ConfigActionDef { - /** - * Afficher l'aide dans la console. - * - * @since 1.0 - */ - HELP( - "Aide", - "org.nuiton.config.example.NuitonConfigExample#help", "-h", "--help"); + private String name; + private String description; + private String action; + private String[] aliases; + public String getName() { + return name; + } - public final String description; - - public final String action; - - public final String[] aliases; - - NuitonConfigExampleConfigAction(String description, String action, String... aliases) { - this.description = description; - this.action = action; - this.aliases = aliases; + public void setName(String name) { + this.name = name; } public String getDescription() { return description; } + public void setDescription(String description) { + this.description = description; + } + + @Override public String getAction() { return action; } + public void setAction(String action) { + this.action = action; + } + + @Override public String[] getAliases() { return aliases; } + public void setAliases(String... aliases) { + this.aliases = aliases; + } } diff --git a/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExampleConfigAction.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/ConfigModel.java similarity index 52% rename from nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExampleConfigAction.java rename to nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/ConfigModel.java index 8f939a9..980b7a2 100644 --- a/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExampleConfigAction.java +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/ConfigModel.java @@ -1,10 +1,10 @@ -package org.nuiton.config.example; +package org.nuiton.config.plugin.model; /*- * #%L - * Nuiton Config :: Example + * Nuiton Config :: Maven plugin * %% - * Copyright (C) 2016 CodeLutin + * Copyright (C) 2016 Code Lutin, Tony Chemit * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as @@ -22,47 +22,41 @@ package org.nuiton.config.example; * #L% */ -import org.nuiton.config.ConfigActionDef; +import java.util.List; /** - * Les actions appellables en ligne de commande. + * Created on 01/10/16. * * @author Tony Chemit - chemit@codelutin.com + * @since 3.0 */ -public enum NuitonConfigExampleConfigAction implements ConfigActionDef { +public class ConfigModel { - /** - * Afficher l'aide dans la console. - * - * @since 1.0 - */ - HELP( - "Aide", - "org.nuiton.config.example.NuitonConfigExample#help", "-h", "--help"); + private String description; + private List<OptionModel> options; + private List<ActionModel> actions; + public String getDescription() { + return description; + } - public final String description; - - public final String action; - - public final String[] aliases; - - NuitonConfigExampleConfigAction(String description, String action, String... aliases) { + public void setDescription(String description) { this.description = description; - this.action = action; - this.aliases = aliases; } - public String getDescription() { - return description; + public List<OptionModel> getOptions() { + return options; } - public String getAction() { - return action; + public void setOptions(List<OptionModel> options) { + this.options = options; } - public String[] getAliases() { - return aliases; + public List<ActionModel> getActions() { + return actions; } + public void setActions(List<ActionModel> actions) { + this.actions = actions; + } } diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/ConfigModelReader.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/ConfigModelReader.java new file mode 100644 index 0000000..45692dc --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/ConfigModelReader.java @@ -0,0 +1,67 @@ +package org.nuiton.config.plugin.model; + +/*- + * #%L + * Nuiton Config :: Maven plugin + * %% + * Copyright (C) 2016 Code Lutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. + * #L% + */ + +import com.esotericsoftware.yamlbeans.YamlConfig; +import com.esotericsoftware.yamlbeans.YamlReader; +import org.nuiton.config.plugin.model.ActionModel; +import org.nuiton.config.plugin.model.ConfigModel; +import org.nuiton.config.plugin.model.OptionModel; + +import java.io.Reader; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; + +/** + * Created on 01/10/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.0 + */ +public class ConfigModelReader { + + public static ConfigModel read(Path file) { + + try (Reader fileReader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) { + YamlReader reader = new YamlReader(fileReader, createConfig()); + return reader.read(ConfigModel.class); + + } catch (Exception e) { + throw new RuntimeException("Could not read config model from file: " + file, e); + } + } + + private static YamlConfig createConfig() { + + YamlConfig yamlConfig = new YamlConfig(); + yamlConfig.setClassTag("option", OptionModel.class); + yamlConfig.setClassTag("action", ActionModel.class); + yamlConfig.writeConfig.setIndentSize(2); + yamlConfig.writeConfig.setWriteRootTags(false); +// yamlConfig.setPropertyElementType(OptionModel.class, "options", OptionModel.class); +// yamlConfig.setPropertyElementType(ActionModel.class, "actions", ActionModel.class); + return yamlConfig; + + } +} diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/OptionModel.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/OptionModel.java new file mode 100644 index 0000000..d984cf5 --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/model/OptionModel.java @@ -0,0 +1,185 @@ +package org.nuiton.config.plugin.model; + +/*- + * #%L + * Nuiton Config :: Maven plugin + * %% + * Copyright (C) 2016 Code Lutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. + * #L% + */ + +import org.nuiton.version.Version; + +import javax.swing.KeyStroke; +import java.awt.Color; +import java.io.File; +import java.net.URL; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.Date; + + +/** + * Created on 01/10/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.0 + */ +public class OptionModel { + + private String name; + private String key; + private String description; + private Class<?> type; + private String defaultValue; + private boolean _transient; + private boolean _final; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getKey() { + return key; + } + + public void setKey(String key) { + this.key = key; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public String getType() { + return type == null ? null : type.getName(); + } + + public void setType(String type) { + + switch (type) { + case "string": + this.type = String.class; + break; + case "int": + this.type = int.class; + break; + case "Integer": + this.type = Integer.class; + break; + case "float": + this.type = float.class; + break; + case "Float": + this.type = Float.class; + break; + case "long": + this.type = long.class; + break; + case "Long": + this.type = Long.class; + break; + case "double": + this.type = double.class; + break; + case "Double": + this.type = Double.class; + break; + case "boolean": + this.type = boolean.class; + break; + case "Boolean": + this.type = Boolean.class; + break; + case "byte": + this.type = byte.class; + break; + case "Byte": + this.type = Byte.class; + break; + case "char": + this.type = char.class; + break; + case "Character": + this.type = Character.class; + break; + case "file": + this.type = File.class; + break; + case "version": + this.type = Version.class; + break; + case "color": + this.type = Color.class; + break; + case "keystroke": + this.type = KeyStroke.class; + break; + case "url": + this.type = URL.class; + break; + case "date": + this.type = Date.class; + break; + case "time": + this.type = Time.class; + break; + case "timestamp": + this.type = Timestamp.class; + break; + default: + try { + this.type = Class.forName(type); + } catch (ClassNotFoundException e) { + throw new RuntimeException("Could not find class: " + type, e); + } + break; + } + } + + public String getDefaultValue() { + return defaultValue; + } + + public void setDefaultValue(String defaultValue) { + this.defaultValue = defaultValue; + } + + public boolean isTransient() { + return _transient; + } + + public boolean isFinal() { + return _final; + } + + public void setTransient(boolean _transient) { + this._transient = _transient; + } + + public void setFinal(boolean _final) { + this._final = _final; + } +} diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8BaseVisitor.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8BaseVisitor.java deleted file mode 100644 index 0dbc444..0000000 --- a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8BaseVisitor.java +++ /dev/null @@ -1,2407 +0,0 @@ -// Generated from Java8.g4 by ANTLR 4.5 -package org.nuiton.config.plugin.parser.java; - -/* - * #%L - * Nuiton Config :: Maven plugin - * %% - * Copyright (C) 2016 Code Lutin, Tony Chemit - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ - -import org.antlr.v4.runtime.misc.NotNull; -import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; - -/** - * This class provides an empty implementation of {@link Java8Visitor}, - * which can be extended to create a visitor which only needs to handle a subset - * of the available methods. - * - * @param <Result> The return type of the visit operation. Use {@link Void} for - * operations with no return type. - */ -public class Java8BaseVisitor<Result> extends AbstractParseTreeVisitor<Result> implements Java8Visitor<Result> { - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitLiteral(@NotNull Java8Parser.LiteralContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitType(@NotNull Java8Parser.TypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPrimitiveType(@NotNull Java8Parser.PrimitiveTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitNumericType(@NotNull Java8Parser.NumericTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitIntegralType(@NotNull Java8Parser.IntegralTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitFloatingPointType(@NotNull Java8Parser.FloatingPointTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitReferenceType(@NotNull Java8Parser.ReferenceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassOrInterfaceType(@NotNull Java8Parser.ClassOrInterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassType(@NotNull Java8Parser.ClassTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassType_lf_classOrInterfaceType(@NotNull Java8Parser.ClassType_lf_classOrInterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassType_lfno_classOrInterfaceType(@NotNull Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInterfaceType(@NotNull Java8Parser.InterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInterfaceType_lf_classOrInterfaceType(@NotNull Java8Parser.InterfaceType_lf_classOrInterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInterfaceType_lfno_classOrInterfaceType(@NotNull Java8Parser.InterfaceType_lfno_classOrInterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeVariable(@NotNull Java8Parser.TypeVariableContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitArrayType(@NotNull Java8Parser.ArrayTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitDims(@NotNull Java8Parser.DimsContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeParameter(@NotNull Java8Parser.TypeParameterContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeParameterModifier(@NotNull Java8Parser.TypeParameterModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeBound(@NotNull Java8Parser.TypeBoundContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAdditionalBound(@NotNull Java8Parser.AdditionalBoundContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeArguments(@NotNull Java8Parser.TypeArgumentsContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeArgumentList(@NotNull Java8Parser.TypeArgumentListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeArgument(@NotNull Java8Parser.TypeArgumentContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitWildcard(@NotNull Java8Parser.WildcardContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitWildcardBounds(@NotNull Java8Parser.WildcardBoundsContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPackageName(@NotNull Java8Parser.PackageNameContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeName(@NotNull Java8Parser.TypeNameContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPackageOrTypeName(@NotNull Java8Parser.PackageOrTypeNameContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitExpressionName(@NotNull Java8Parser.ExpressionNameContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodName(@NotNull Java8Parser.MethodNameContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAmbiguousName(@NotNull Java8Parser.AmbiguousNameContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitCompilationUnit(@NotNull Java8Parser.CompilationUnitContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPackageDeclaration(@NotNull Java8Parser.PackageDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPackageModifier(@NotNull Java8Parser.PackageModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitImportDeclaration(@NotNull Java8Parser.ImportDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSingleTypeImportDeclaration(@NotNull Java8Parser.SingleTypeImportDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeImportOnDemandDeclaration(@NotNull Java8Parser.TypeImportOnDemandDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSingleStaticImportDeclaration(@NotNull Java8Parser.SingleStaticImportDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitStaticImportOnDemandDeclaration(@NotNull Java8Parser.StaticImportOnDemandDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeDeclaration(@NotNull Java8Parser.TypeDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassDeclaration(@NotNull Java8Parser.ClassDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitNormalClassDeclaration(@NotNull Java8Parser.NormalClassDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassModifier(@NotNull Java8Parser.ClassModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeParameters(@NotNull Java8Parser.TypeParametersContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeParameterList(@NotNull Java8Parser.TypeParameterListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSuperclass(@NotNull Java8Parser.SuperclassContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSuperinterfaces(@NotNull Java8Parser.SuperinterfacesContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInterfaceTypeList(@NotNull Java8Parser.InterfaceTypeListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassBody(@NotNull Java8Parser.ClassBodyContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassBodyDeclaration(@NotNull Java8Parser.ClassBodyDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassMemberDeclaration(@NotNull Java8Parser.ClassMemberDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitFieldDeclaration(@NotNull Java8Parser.FieldDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitFieldModifier(@NotNull Java8Parser.FieldModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitVariableDeclaratorList(@NotNull Java8Parser.VariableDeclaratorListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitVariableDeclarator(@NotNull Java8Parser.VariableDeclaratorContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitVariableDeclaratorId(@NotNull Java8Parser.VariableDeclaratorIdContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitVariableInitializer(@NotNull Java8Parser.VariableInitializerContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannType(@NotNull Java8Parser.UnannTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannPrimitiveType(@NotNull Java8Parser.UnannPrimitiveTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannReferenceType(@NotNull Java8Parser.UnannReferenceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannClassOrInterfaceType(@NotNull Java8Parser.UnannClassOrInterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannClassType(@NotNull Java8Parser.UnannClassTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannClassType_lf_unannClassOrInterfaceType(@NotNull Java8Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannClassType_lfno_unannClassOrInterfaceType(@NotNull Java8Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannInterfaceType(@NotNull Java8Parser.UnannInterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannInterfaceType_lf_unannClassOrInterfaceType(@NotNull Java8Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannInterfaceType_lfno_unannClassOrInterfaceType(@NotNull Java8Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannTypeVariable(@NotNull Java8Parser.UnannTypeVariableContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnannArrayType(@NotNull Java8Parser.UnannArrayTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodDeclaration(@NotNull Java8Parser.MethodDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodModifier(@NotNull Java8Parser.MethodModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodHeader(@NotNull Java8Parser.MethodHeaderContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitResult(@NotNull Java8Parser.ResultContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodDeclarator(@NotNull Java8Parser.MethodDeclaratorContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitFormalParameterList(@NotNull Java8Parser.FormalParameterListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitFormalParameters(@NotNull Java8Parser.FormalParametersContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitFormalParameter(@NotNull Java8Parser.FormalParameterContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitVariableModifier(@NotNull Java8Parser.VariableModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitLastFormalParameter(@NotNull Java8Parser.LastFormalParameterContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitReceiverParameter(@NotNull Java8Parser.ReceiverParameterContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitThrows_(@NotNull Java8Parser.Throws_Context ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitExceptionTypeList(@NotNull Java8Parser.ExceptionTypeListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitExceptionType(@NotNull Java8Parser.ExceptionTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodBody(@NotNull Java8Parser.MethodBodyContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInstanceInitializer(@NotNull Java8Parser.InstanceInitializerContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitStaticInitializer(@NotNull Java8Parser.StaticInitializerContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitConstructorDeclaration(@NotNull Java8Parser.ConstructorDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitConstructorModifier(@NotNull Java8Parser.ConstructorModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitConstructorDeclarator(@NotNull Java8Parser.ConstructorDeclaratorContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSimpleTypeName(@NotNull Java8Parser.SimpleTypeNameContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitConstructorBody(@NotNull Java8Parser.ConstructorBodyContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitExplicitConstructorInvocation(@NotNull Java8Parser.ExplicitConstructorInvocationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitEnumDeclaration(@NotNull Java8Parser.EnumDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitEnumBody(@NotNull Java8Parser.EnumBodyContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitEnumConstantList(@NotNull Java8Parser.EnumConstantListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitEnumConstant(@NotNull Java8Parser.EnumConstantContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitEnumConstantModifier(@NotNull Java8Parser.EnumConstantModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitEnumBodyDeclarations(@NotNull Java8Parser.EnumBodyDeclarationsContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInterfaceDeclaration(@NotNull Java8Parser.InterfaceDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitNormalInterfaceDeclaration(@NotNull Java8Parser.NormalInterfaceDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInterfaceModifier(@NotNull Java8Parser.InterfaceModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitExtendsInterfaces(@NotNull Java8Parser.ExtendsInterfacesContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInterfaceBody(@NotNull Java8Parser.InterfaceBodyContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInterfaceMemberDeclaration(@NotNull Java8Parser.InterfaceMemberDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitConstantDeclaration(@NotNull Java8Parser.ConstantDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitConstantModifier(@NotNull Java8Parser.ConstantModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInterfaceMethodDeclaration(@NotNull Java8Parser.InterfaceMethodDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInterfaceMethodModifier(@NotNull Java8Parser.InterfaceMethodModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAnnotationTypeDeclaration(@NotNull Java8Parser.AnnotationTypeDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAnnotationTypeBody(@NotNull Java8Parser.AnnotationTypeBodyContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAnnotationTypeMemberDeclaration(@NotNull Java8Parser.AnnotationTypeMemberDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAnnotationTypeElementDeclaration(@NotNull Java8Parser.AnnotationTypeElementDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAnnotationTypeElementModifier(@NotNull Java8Parser.AnnotationTypeElementModifierContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitDefaultValue(@NotNull Java8Parser.DefaultValueContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAnnotation(@NotNull Java8Parser.AnnotationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitNormalAnnotation(@NotNull Java8Parser.NormalAnnotationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitElementValuePairList(@NotNull Java8Parser.ElementValuePairListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitElementValuePair(@NotNull Java8Parser.ElementValuePairContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitElementValue(@NotNull Java8Parser.ElementValueContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitElementValueArrayInitializer(@NotNull Java8Parser.ElementValueArrayInitializerContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitElementValueList(@NotNull Java8Parser.ElementValueListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMarkerAnnotation(@NotNull Java8Parser.MarkerAnnotationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSingleElementAnnotation(@NotNull Java8Parser.SingleElementAnnotationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitArrayInitializer(@NotNull Java8Parser.ArrayInitializerContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitVariableInitializerList(@NotNull Java8Parser.VariableInitializerListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitBlock(@NotNull Java8Parser.BlockContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitBlockStatements(@NotNull Java8Parser.BlockStatementsContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitBlockStatement(@NotNull Java8Parser.BlockStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitLocalVariableDeclarationStatement(@NotNull Java8Parser.LocalVariableDeclarationStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitLocalVariableDeclaration(@NotNull Java8Parser.LocalVariableDeclarationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitStatement(@NotNull Java8Parser.StatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitStatementNoShortIf(@NotNull Java8Parser.StatementNoShortIfContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitStatementWithoutTrailingSubstatement(@NotNull Java8Parser.StatementWithoutTrailingSubstatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitEmptyStatement(@NotNull Java8Parser.EmptyStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitLabeledStatement(@NotNull Java8Parser.LabeledStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitLabeledStatementNoShortIf(@NotNull Java8Parser.LabeledStatementNoShortIfContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitExpressionStatement(@NotNull Java8Parser.ExpressionStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitStatementExpression(@NotNull Java8Parser.StatementExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitIfThenStatement(@NotNull Java8Parser.IfThenStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitIfThenElseStatement(@NotNull Java8Parser.IfThenElseStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitIfThenElseStatementNoShortIf(@NotNull Java8Parser.IfThenElseStatementNoShortIfContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAssertStatement(@NotNull Java8Parser.AssertStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSwitchStatement(@NotNull Java8Parser.SwitchStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSwitchBlock(@NotNull Java8Parser.SwitchBlockContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSwitchBlockStatementGroup(@NotNull Java8Parser.SwitchBlockStatementGroupContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSwitchLabels(@NotNull Java8Parser.SwitchLabelsContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSwitchLabel(@NotNull Java8Parser.SwitchLabelContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitEnumConstantName(@NotNull Java8Parser.EnumConstantNameContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitWhileStatement(@NotNull Java8Parser.WhileStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitWhileStatementNoShortIf(@NotNull Java8Parser.WhileStatementNoShortIfContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitDoStatement(@NotNull Java8Parser.DoStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitForStatement(@NotNull Java8Parser.ForStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitForStatementNoShortIf(@NotNull Java8Parser.ForStatementNoShortIfContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitBasicForStatement(@NotNull Java8Parser.BasicForStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitBasicForStatementNoShortIf(@NotNull Java8Parser.BasicForStatementNoShortIfContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitForInit(@NotNull Java8Parser.ForInitContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitForUpdate(@NotNull Java8Parser.ForUpdateContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitStatementExpressionList(@NotNull Java8Parser.StatementExpressionListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitEnhancedForStatement(@NotNull Java8Parser.EnhancedForStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitEnhancedForStatementNoShortIf(@NotNull Java8Parser.EnhancedForStatementNoShortIfContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitBreakStatement(@NotNull Java8Parser.BreakStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitContinueStatement(@NotNull Java8Parser.ContinueStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitReturnStatement(@NotNull Java8Parser.ReturnStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitThrowStatement(@NotNull Java8Parser.ThrowStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitSynchronizedStatement(@NotNull Java8Parser.SynchronizedStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTryStatement(@NotNull Java8Parser.TryStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitCatches(@NotNull Java8Parser.CatchesContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitCatchClause(@NotNull Java8Parser.CatchClauseContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitCatchFormalParameter(@NotNull Java8Parser.CatchFormalParameterContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitCatchType(@NotNull Java8Parser.CatchTypeContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitFinally_(@NotNull Java8Parser.Finally_Context ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTryWithResourcesStatement(@NotNull Java8Parser.TryWithResourcesStatementContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitResourceSpecification(@NotNull Java8Parser.ResourceSpecificationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitResourceList(@NotNull Java8Parser.ResourceListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitResource(@NotNull Java8Parser.ResourceContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPrimary(@NotNull Java8Parser.PrimaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPrimaryNoNewArray(@NotNull Java8Parser.PrimaryNoNewArrayContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPrimaryNoNewArray_lf_arrayAccess(@NotNull Java8Parser.PrimaryNoNewArray_lf_arrayAccessContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPrimaryNoNewArray_lfno_arrayAccess(@NotNull Java8Parser.PrimaryNoNewArray_lfno_arrayAccessContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPrimaryNoNewArray_lf_primary(@NotNull Java8Parser.PrimaryNoNewArray_lf_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(@NotNull Java8Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(@NotNull Java8Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPrimaryNoNewArray_lfno_primary(@NotNull Java8Parser.PrimaryNoNewArray_lfno_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(@NotNull Java8Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(@NotNull Java8Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassInstanceCreationExpression(@NotNull Java8Parser.ClassInstanceCreationExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassInstanceCreationExpression_lf_primary(@NotNull Java8Parser.ClassInstanceCreationExpression_lf_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitClassInstanceCreationExpression_lfno_primary(@NotNull Java8Parser.ClassInstanceCreationExpression_lfno_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitTypeArgumentsOrDiamond(@NotNull Java8Parser.TypeArgumentsOrDiamondContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitFieldAccess(@NotNull Java8Parser.FieldAccessContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitFieldAccess_lf_primary(@NotNull Java8Parser.FieldAccess_lf_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitFieldAccess_lfno_primary(@NotNull Java8Parser.FieldAccess_lfno_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitArrayAccess(@NotNull Java8Parser.ArrayAccessContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitArrayAccess_lf_primary(@NotNull Java8Parser.ArrayAccess_lf_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitArrayAccess_lfno_primary(@NotNull Java8Parser.ArrayAccess_lfno_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodInvocation(@NotNull Java8Parser.MethodInvocationContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodInvocation_lf_primary(@NotNull Java8Parser.MethodInvocation_lf_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodInvocation_lfno_primary(@NotNull Java8Parser.MethodInvocation_lfno_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitArgumentList(@NotNull Java8Parser.ArgumentListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodReference(@NotNull Java8Parser.MethodReferenceContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodReference_lf_primary(@NotNull Java8Parser.MethodReference_lf_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMethodReference_lfno_primary(@NotNull Java8Parser.MethodReference_lfno_primaryContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitArrayCreationExpression(@NotNull Java8Parser.ArrayCreationExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitDimExprs(@NotNull Java8Parser.DimExprsContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitDimExpr(@NotNull Java8Parser.DimExprContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitConstantExpression(@NotNull Java8Parser.ConstantExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitExpression(@NotNull Java8Parser.ExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitLambdaExpression(@NotNull Java8Parser.LambdaExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitLambdaParameters(@NotNull Java8Parser.LambdaParametersContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInferredFormalParameterList(@NotNull Java8Parser.InferredFormalParameterListContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitLambdaBody(@NotNull Java8Parser.LambdaBodyContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAssignmentExpression(@NotNull Java8Parser.AssignmentExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAssignment(@NotNull Java8Parser.AssignmentContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitLeftHandSide(@NotNull Java8Parser.LeftHandSideContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAssignmentOperator(@NotNull Java8Parser.AssignmentOperatorContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitConditionalExpression(@NotNull Java8Parser.ConditionalExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitConditionalOrExpression(@NotNull Java8Parser.ConditionalOrExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitConditionalAndExpression(@NotNull Java8Parser.ConditionalAndExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitInclusiveOrExpression(@NotNull Java8Parser.InclusiveOrExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitExclusiveOrExpression(@NotNull Java8Parser.ExclusiveOrExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAndExpression(@NotNull Java8Parser.AndExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitEqualityExpression(@NotNull Java8Parser.EqualityExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitRelationalExpression(@NotNull Java8Parser.RelationalExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitShiftExpression(@NotNull Java8Parser.ShiftExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitAdditiveExpression(@NotNull Java8Parser.AdditiveExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitMultiplicativeExpression(@NotNull Java8Parser.MultiplicativeExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnaryExpression(@NotNull Java8Parser.UnaryExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPreIncrementExpression(@NotNull Java8Parser.PreIncrementExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPreDecrementExpression(@NotNull Java8Parser.PreDecrementExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitUnaryExpressionNotPlusMinus(@NotNull Java8Parser.UnaryExpressionNotPlusMinusContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPostfixExpression(@NotNull Java8Parser.PostfixExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPostIncrementExpression(@NotNull Java8Parser.PostIncrementExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPostIncrementExpression_lf_postfixExpression(@NotNull Java8Parser.PostIncrementExpression_lf_postfixExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPostDecrementExpression(@NotNull Java8Parser.PostDecrementExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitPostDecrementExpression_lf_postfixExpression(@NotNull Java8Parser.PostDecrementExpression_lf_postfixExpressionContext ctx) { - return visitChildren(ctx); - } - - /** - * {@inheritDoc} - * <p>The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}.</p> - */ - @Override - public Result visitCastExpression(@NotNull Java8Parser.CastExpressionContext ctx) { - return visitChildren(ctx); - } -} diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Lexer.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Lexer.java deleted file mode 100644 index d652952..0000000 --- a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Lexer.java +++ /dev/null @@ -1,611 +0,0 @@ -// Generated from Java8.g4 by ANTLR 4.5 -package org.nuiton.config.plugin.parser.java; - -/* - * #%L - * Nuiton Config :: Maven plugin - * %% - * Copyright (C) 2016 Code Lutin, Tony Chemit - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ - -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.Lexer; -import org.antlr.v4.runtime.RuleContext; -import org.antlr.v4.runtime.Vocabulary; -import org.antlr.v4.runtime.VocabularyImpl; -import org.antlr.v4.runtime.atn.ATN; -import org.antlr.v4.runtime.atn.ATNDeserializer; -import org.antlr.v4.runtime.atn.LexerATNSimulator; -import org.antlr.v4.runtime.misc.NotNull; - -public class Java8Lexer extends Lexer { - public static final int - ABSTRACT = 1, ASSERT = 2, BOOLEAN = 3, BREAK = 4, BYTE = 5, CASE = 6, CATCH = 7, CHAR = 8, - CLASS = 9, CONST = 10, CONTINUE = 11, DEFAULT = 12, DO = 13, DOUBLE = 14, ELSE = 15, - ENUM = 16, EXTENDS = 17, FINAL = 18, FINALLY = 19, FLOAT = 20, FOR = 21, IF = 22, GOTO = 23, - IMPLEMENTS = 24, IMPORT = 25, INSTANCEOF = 26, INT = 27, INTERFACE = 28, LONG = 29, - NATIVE = 30, NEW = 31, PACKAGE = 32, PRIVATE = 33, PROTECTED = 34, PUBLIC = 35, RETURN = 36, - SHORT = 37, STATIC = 38, STRICTFP = 39, SUPER = 40, SWITCH = 41, SYNCHRONIZED = 42, - THIS = 43, THROW = 44, THROWS = 45, TRANSIENT = 46, TRY = 47, VOID = 48, VOLATILE = 49, - WHILE = 50, IntegerLiteral = 51, FloatingPointLiteral = 52, BooleanLiteral = 53, - CharacterLiteral = 54, StringLiteral = 55, NullLiteral = 56, LPAREN = 57, RPAREN = 58, - LBRACE = 59, RBRACE = 60, LBRACK = 61, RBRACK = 62, SEMI = 63, COMMA = 64, DOT = 65, - ASSIGN = 66, GT = 67, LT = 68, BANG = 69, TILDE = 70, QUESTION = 71, COLON = 72, EQUAL = 73, - LE = 74, GE = 75, NOTEQUAL = 76, AND = 77, OR = 78, INC = 79, DEC = 80, ADD = 81, SUB = 82, - MUL = 83, DIV = 84, BITAND = 85, BITOR = 86, CARET = 87, MOD = 88, ARROW = 89, COLONCOLON = 90, - ADD_ASSIGN = 91, SUB_ASSIGN = 92, MUL_ASSIGN = 93, DIV_ASSIGN = 94, AND_ASSIGN = 95, - OR_ASSIGN = 96, XOR_ASSIGN = 97, MOD_ASSIGN = 98, LSHIFT_ASSIGN = 99, RSHIFT_ASSIGN = 100, - URSHIFT_ASSIGN = 101, Identifier = 102, AT = 103, ELLIPSIS = 104, WS = 105, COMMENT = 106, - LINE_COMMENT = 107; - public static String[] modeNames = { - "DEFAULT_MODE" - }; - - public static final String[] ruleNames = { - "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", - "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", - "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", - "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", - "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", - "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", - "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "DecimalIntegerLiteral", - "HexIntegerLiteral", "OctalIntegerLiteral", "BinaryIntegerLiteral", "IntegerTypeSuffix", - "DecimalNumeral", "Digits", "Digit", "NonZeroDigit", "DigitsAndUnderscores", - "DigitOrUnderscore", "Underscores", "HexNumeral", "HexDigits", "HexDigit", - "HexDigitsAndUnderscores", "HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", - "OctalDigit", "OctalDigitsAndUnderscores", "OctalDigitOrUnderscore", "BinaryNumeral", - "BinaryDigits", "BinaryDigit", "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", - "FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", - "ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", - "HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", - "CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", - "StringCharacter", "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", - "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", - "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", - "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", - "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", - "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", - "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", - "URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", "AT", - "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" - }; - - private static final String[] _LITERAL_NAMES = { - null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", - "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", - "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", - "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", - "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", - "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", - "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", - "'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, - null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", - "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", - "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", - "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", - "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", - "'>>>='", null, "'@'", "'...'" - }; - private static final String[] _SYMBOLIC_NAMES = { - null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", - "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", - "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", - "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", - "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", - "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", - "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "FloatingPointLiteral", - "BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral", - "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", - "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", - "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", - "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", "ADD_ASSIGN", - "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", - "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", - "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" - }; - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); - - /** - * @deprecated Use {@link #VOCABULARY} instead. - */ - @Deprecated - public static final String[] tokenNames; - - static { - tokenNames = new String[_SYMBOLIC_NAMES.length]; - for (int i = 0; i < tokenNames.length; i++) { - tokenNames[i] = VOCABULARY.getLiteralName(i); - if (tokenNames[i] == null) { - tokenNames[i] = VOCABULARY.getSymbolicName(i); - } - - if (tokenNames[i] == null) { - tokenNames[i] = "<INVALID>"; - } - } - } - - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } - - @Override - @NotNull - public Vocabulary getVocabulary() { - return VOCABULARY; - } - - - public Java8Lexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this, _ATN); - } - - @Override - public String getGrammarFileName() { - return "Java8.g4"; - } - - @Override - public String[] getRuleNames() { - return ruleNames; - } - - @Override - public String getSerializedATN() { - return _serializedATN; - } - - @Override - public String[] getModeNames() { - return modeNames; - } - - @Override - public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { - switch (ruleIndex) { - case 146: - return JavaLetter_sempred(_localctx, predIndex); - case 147: - return JavaLetterOrDigit_sempred(_localctx, predIndex); - } - return true; - } - - private boolean JavaLetter_sempred(RuleContext _localctx, int predIndex) { - switch (predIndex) { - case 0: - return Character.isJavaIdentifierStart(_input.LA(-1)); - case 1: - return Character.isJavaIdentifierStart(Character.toCodePoint((char) _input.LA(-2), (char) _input.LA(-1))); - } - return true; - } - - private boolean JavaLetterOrDigit_sempred(RuleContext _localctx, int predIndex) { - switch (predIndex) { - case 2: - return Character.isJavaIdentifierPart(_input.LA(-1)); - case 3: - return Character.isJavaIdentifierPart(Character.toCodePoint((char) _input.LA(-2), (char) _input.LA(-1))); - } - return true; - } - - public static final String _serializedATN = - "\3\uaf6f\u8320\u479d\ub75c\u4880\u1605\u191c\uab37\2m\u0448\b\1\4\2\t" + - "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13" + - "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22" + - "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31" + - "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!" + - "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4" + - ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t" + - "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t=" + - "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I" + - "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT" + - "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4" + - "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t" + - "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4" + - "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080" + - "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085" + - "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089" + - "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e" + - "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092" + - "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097" + - "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\3\2\3\2\3\2\3" + - "\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4" + - "\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3" + - "\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n" + - "\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f" + - "\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3" + - "\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\22\3" + - "\22\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3" + - "\24\3\24\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3" + - "\26\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3" + - "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3" + - "\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3" + - "\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3" + - "\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3!" + - "\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\3" + - "#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3" + - "\'\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3" + - ")\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3,\3,\3" + - ",\3,\3,\3-\3-\3-\3-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3" + - "/\3/\3/\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3" + - "\62\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3" + - "\64\3\64\5\64\u028d\n\64\3\65\3\65\5\65\u0291\n\65\3\66\3\66\5\66\u0295" + - "\n\66\3\67\3\67\5\67\u0299\n\67\38\38\58\u029d\n8\39\39\3:\3:\3:\5:\u02a4" + - "\n:\3:\3:\3:\5:\u02a9\n:\5:\u02ab\n:\3;\3;\5;\u02af\n;\3;\5;\u02b2\n;" + - "\3<\3<\5<\u02b6\n<\3=\3=\3>\6>\u02bb\n>\r>\16>\u02bc\3?\3?\5?\u02c1\n" + - "?\3@\6@\u02c4\n@\r@\16@\u02c5\3A\3A\3A\3A\3B\3B\5B\u02ce\nB\3B\5B\u02d1" + - "\nB\3C\3C\3D\6D\u02d6\nD\rD\16D\u02d7\3E\3E\5E\u02dc\nE\3F\3F\5F\u02e0" + - "\nF\3F\3F\3G\3G\5G\u02e6\nG\3G\5G\u02e9\nG\3H\3H\3I\6I\u02ee\nI\rI\16" + - "I\u02ef\3J\3J\5J\u02f4\nJ\3K\3K\3K\3K\3L\3L\5L\u02fc\nL\3L\5L\u02ff\n" + - "L\3M\3M\3N\6N\u0304\nN\rN\16N\u0305\3O\3O\5O\u030a\nO\3P\3P\5P\u030e\n" + - "P\3Q\3Q\3Q\5Q\u0313\nQ\3Q\5Q\u0316\nQ\3Q\5Q\u0319\nQ\3Q\3Q\3Q\5Q\u031e" + - "\nQ\3Q\5Q\u0321\nQ\3Q\3Q\3Q\5Q\u0326\nQ\3Q\3Q\3Q\5Q\u032b\nQ\3R\3R\3R" + - "\3S\3S\3T\5T\u0333\nT\3T\3T\3U\3U\3V\3V\3W\3W\3W\5W\u033e\nW\3X\3X\5X" + - "\u0342\nX\3X\3X\3X\5X\u0347\nX\3X\3X\5X\u034b\nX\3Y\3Y\3Y\3Z\3Z\3[\3[" + - "\3[\3[\3[\3[\3[\3[\3[\5[\u035b\n[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\5\\" + - "\u0365\n\\\3]\3]\3^\3^\5^\u036b\n^\3^\3^\3_\6_\u0370\n_\r_\16_\u0371\3" + - "`\3`\5`\u0376\n`\3a\3a\3a\3a\5a\u037c\na\3b\3b\3b\3b\3b\3b\3b\3b\3b\3" + - "b\3b\5b\u0389\nb\3c\3c\3d\3d\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3f\3f\3g\3" + - "g\3h\3h\3i\3i\3j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3o\3o\3p\3p\3q\3q\3r\3r\3" + - "s\3s\3t\3t\3u\3u\3v\3v\3v\3w\3w\3w\3x\3x\3x\3y\3y\3y\3z\3z\3z\3{\3{\3" + - "{\3|\3|\3|\3}\3}\3}\3~\3~\3\177\3\177\3\u0080\3\u0080\3\u0081\3\u0081" + - "\3\u0082\3\u0082\3\u0083\3\u0083\3\u0084\3\u0084\3\u0085\3\u0085\3\u0086" + - "\3\u0086\3\u0086\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\3\u0089" + - "\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008c" + - "\3\u008c\3\u008c\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e\3\u008f" + - "\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091" + - "\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0093\3\u0093\7\u0093" + - "\u040e\n\u0093\f\u0093\16\u0093\u0411\13\u0093\3\u0094\3\u0094\3\u0094" + - "\3\u0094\3\u0094\3\u0094\5\u0094\u0419\n\u0094\3\u0095\3\u0095\3\u0095" + - "\3\u0095\3\u0095\3\u0095\5\u0095\u0421\n\u0095\3\u0096\3\u0096\3\u0097" + - "\3\u0097\3\u0097\3\u0097\3\u0098\6\u0098\u042a\n\u0098\r\u0098\16\u0098" + - "\u042b\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\7\u0099\u0434\n" + - "\u0099\f\u0099\16\u0099\u0437\13\u0099\3\u0099\3\u0099\3\u0099\3\u0099" + - "\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\7\u009a\u0442\n\u009a\f\u009a" + - "\16\u009a\u0445\13\u009a\3\u009a\3\u009a\3\u0435\2\2\u009b\3\2\3\5\2\4" + - "\7\2\5\t\2\6\13\2\7\r\2\b\17\2\t\21\2\n\23\2\13\25\2\f\27\2\r\31\2\16" + - "\33\2\17\35\2\20\37\2\21!\2\22#\2\23%\2\24\'\2\25)\2\26+\2\27-\2\30/\2" + - "\31\61\2\32\63\2\33\65\2\34\67\2\359\2\36;\2\37=\2 ?\2!A\2\"C\2#E\2$G" + - "\2%I\2&K\2\'M\2(O\2)Q\2*S\2+U\2,W\2-Y\2.[\2/]\2\60_\2\61a\2\62c\2\63e" + - "\2\64g\2\65i\2\2k\2\2m\2\2o\2\2q\2\2s\2\2u\2\2w\2\2y\2\2{\2\2}\2\2\177" + - "\2\2\u0081\2\2\u0083\2\2\u0085\2\2\u0087\2\2\u0089\2\2\u008b\2\2\u008d" + - "\2\2\u008f\2\2\u0091\2\2\u0093\2\2\u0095\2\2\u0097\2\2\u0099\2\2\u009b" + - "\2\2\u009d\2\2\u009f\2\66\u00a1\2\2\u00a3\2\2\u00a5\2\2\u00a7\2\2\u00a9" + - "\2\2\u00ab\2\2\u00ad\2\2\u00af\2\2\u00b1\2\2\u00b3\2\2\u00b5\2\67\u00b7" + - "\28\u00b9\2\2\u00bb\29\u00bd\2\2\u00bf\2\2\u00c1\2\2\u00c3\2\2\u00c5\2" + - "\2\u00c7\2\2\u00c9\2:\u00cb\2;\u00cd\2<\u00cf\2=\u00d1\2>\u00d3\2?\u00d5" + - "\2@\u00d7\2A\u00d9\2B\u00db\2C\u00dd\2D\u00df\2E\u00e1\2F\u00e3\2G\u00e5" + - "\2H\u00e7\2I\u00e9\2J\u00eb\2K\u00ed\2L\u00ef\2M\u00f1\2N\u00f3\2O\u00f5" + - "\2P\u00f7\2Q\u00f9\2R\u00fb\2S\u00fd\2T\u00ff\2U\u0101\2V\u0103\2W\u0105" + - "\2X\u0107\2Y\u0109\2Z\u010b\2[\u010d\2\\\u010f\2]\u0111\2^\u0113\2_\u0115" + - "\2`\u0117\2a\u0119\2b\u011b\2c\u011d\2d\u011f\2e\u0121\2f\u0123\2g\u0125" + - "\2h\u0127\2\2\u0129\2\2\u012b\2i\u012d\2j\u012f\2k\u0131\2l\u0133\2m\3" + - "\2\30\4\2NNnn\3\2\63;\4\2ZZzz\5\2\62;CHch\3\2\629\4\2DDdd\3\2\62\63\4" + - "\2GGgg\4\2--//\6\2FFHHffhh\4\2RRrr\4\2))^^\4\2$$^^\n\2$$))^^ddhhppttv" + - "v\3\2\62\65\6\2&&C\\aac|\4\2\2\u0081\ud802\udc01\3\2\ud802\udc01\3\2\udc02" + - "\ue001\7\2&&\62;C\\aac|\5\2\13\f\16\17\"\"\4\2\f\f\17\17\u0456\2\3\3\2" + - "\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17" + - "\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2" + - "\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3" + - "\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3" + - "\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2" + - "=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3" + - "\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2" + - "\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2" + - "c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2\u009f\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7" + - "\3\2\2\2\2\u00bb\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2" + - "\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7" + - "\3\2\2\2\2\u00d9\3\2\2\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2" + - "\2\2\u00e1\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9" + - "\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2" + - "\2\2\u00f3\3\2\2\2\2\u00f5\3\2\2\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb" + - "\3\2\2\2\2\u00fd\3\2\2\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2" + - "\2\2\u0105\3\2\2\2\2\u0107\3\2\2\2\2\u0109\3\2\2\2\2\u010b\3\2\2\2\2\u010d" + - "\3\2\2\2\2\u010f\3\2\2\2\2\u0111\3\2\2\2\2\u0113\3\2\2\2\2\u0115\3\2\2" + - "\2\2\u0117\3\2\2\2\2\u0119\3\2\2\2\2\u011b\3\2\2\2\2\u011d\3\2\2\2\2\u011f" + - "\3\2\2\2\2\u0121\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2\2\2\u012b\3\2\2" + - "\2\2\u012d\3\2\2\2\2\u012f\3\2\2\2\2\u0131\3\2\2\2\2\u0133\3\2\2\2\3\u0135" + - "\3\2\2\2\5\u013e\3\2\2\2\7\u0145\3\2\2\2\t\u014d\3\2\2\2\13\u0153\3\2" + - "\2\2\r\u0158\3\2\2\2\17\u015d\3\2\2\2\21\u0163\3\2\2\2\23\u0168\3\2\2" + - "\2\25\u016e\3\2\2\2\27\u0174\3\2\2\2\31\u017d\3\2\2\2\33\u0185\3\2\2\2" + - "\35\u0188\3\2\2\2\37\u018f\3\2\2\2!\u0194\3\2\2\2#\u0199\3\2\2\2%\u01a1" + - "\3\2\2\2\'\u01a7\3\2\2\2)\u01af\3\2\2\2+\u01b5\3\2\2\2-\u01b9\3\2\2\2" + - "/\u01bc\3\2\2\2\61\u01c1\3\2\2\2\63\u01cc\3\2\2\2\65\u01d3\3\2\2\2\67" + - "\u01de\3\2\2\29\u01e2\3\2\2\2;\u01ec\3\2\2\2=\u01f1\3\2\2\2?\u01f8\3\2" + - "\2\2A\u01fc\3\2\2\2C\u0204\3\2\2\2E\u020c\3\2\2\2G\u0216\3\2\2\2I\u021d" + - "\3\2\2\2K\u0224\3\2\2\2M\u022a\3\2\2\2O\u0231\3\2\2\2Q\u023a\3\2\2\2S" + - "\u0240\3\2\2\2U\u0247\3\2\2\2W\u0254\3\2\2\2Y\u0259\3\2\2\2[\u025f\3\2" + - "\2\2]\u0266\3\2\2\2_\u0270\3\2\2\2a\u0274\3\2\2\2c\u0279\3\2\2\2e\u0282" + - "\3\2\2\2g\u028c\3\2\2\2i\u028e\3\2\2\2k\u0292\3\2\2\2m\u0296\3\2\2\2o" + - "\u029a\3\2\2\2q\u029e\3\2\2\2s\u02aa\3\2\2\2u\u02ac\3\2\2\2w\u02b5\3\2" + - "\2\2y\u02b7\3\2\2\2{\u02ba\3\2\2\2}\u02c0\3\2\2\2\177\u02c3\3\2\2\2\u0081" + - "\u02c7\3\2\2\2\u0083\u02cb\3\2\2\2\u0085\u02d2\3\2\2\2\u0087\u02d5\3\2" + - "\2\2\u0089\u02db\3\2\2\2\u008b\u02dd\3\2\2\2\u008d\u02e3\3\2\2\2\u008f" + - "\u02ea\3\2\2\2\u0091\u02ed\3\2\2\2\u0093\u02f3\3\2\2\2\u0095\u02f5\3\2" + - "\2\2\u0097\u02f9\3\2\2\2\u0099\u0300\3\2\2\2\u009b\u0303\3\2\2\2\u009d" + - "\u0309\3\2\2\2\u009f\u030d\3\2\2\2\u00a1\u032a\3\2\2\2\u00a3\u032c\3\2" + - "\2\2\u00a5\u032f\3\2\2\2\u00a7\u0332\3\2\2\2\u00a9\u0336\3\2\2\2\u00ab" + - "\u0338\3\2\2\2\u00ad\u033a\3\2\2\2\u00af\u034a\3\2\2\2\u00b1\u034c\3\2" + - "\2\2\u00b3\u034f\3\2\2\2\u00b5\u035a\3\2\2\2\u00b7\u0364\3\2\2\2\u00b9" + - "\u0366\3\2\2\2\u00bb\u0368\3\2\2\2\u00bd\u036f\3\2\2\2\u00bf\u0375\3\2" + - "\2\2\u00c1\u037b\3\2\2\2\u00c3\u0388\3\2\2\2\u00c5\u038a\3\2\2\2\u00c7" + - "\u038c\3\2\2\2\u00c9\u0393\3\2\2\2\u00cb\u0398\3\2\2\2\u00cd\u039a\3\2" + - "\2\2\u00cf\u039c\3\2\2\2\u00d1\u039e\3\2\2\2\u00d3\u03a0\3\2\2\2\u00d5" + - "\u03a2\3\2\2\2\u00d7\u03a4\3\2\2\2\u00d9\u03a6\3\2\2\2\u00db\u03a8\3\2" + - "\2\2\u00dd\u03aa\3\2\2\2\u00df\u03ac\3\2\2\2\u00e1\u03ae\3\2\2\2\u00e3" + - "\u03b0\3\2\2\2\u00e5\u03b2\3\2\2\2\u00e7\u03b4\3\2\2\2\u00e9\u03b6\3\2" + - "\2\2\u00eb\u03b8\3\2\2\2\u00ed\u03bb\3\2\2\2\u00ef\u03be\3\2\2\2\u00f1" + - "\u03c1\3\2\2\2\u00f3\u03c4\3\2\2\2\u00f5\u03c7\3\2\2\2\u00f7\u03ca\3\2" + - "\2\2\u00f9\u03cd\3\2\2\2\u00fb\u03d0\3\2\2\2\u00fd\u03d2\3\2\2\2\u00ff" + - "\u03d4\3\2\2\2\u0101\u03d6\3\2\2\2\u0103\u03d8\3\2\2\2\u0105\u03da\3\2" + - "\2\2\u0107\u03dc\3\2\2\2\u0109\u03de\3\2\2\2\u010b\u03e0\3\2\2\2\u010d" + - "\u03e3\3\2\2\2\u010f\u03e6\3\2\2\2\u0111\u03e9\3\2\2\2\u0113\u03ec\3\2" + - "\2\2\u0115\u03ef\3\2\2\2\u0117\u03f2\3\2\2\2\u0119\u03f5\3\2\2\2\u011b" + - "\u03f8\3\2\2\2\u011d\u03fb\3\2\2\2\u011f\u03fe\3\2\2\2\u0121\u0402\3\2" + - "\2\2\u0123\u0406\3\2\2\2\u0125\u040b\3\2\2\2\u0127\u0418\3\2\2\2\u0129" + - "\u0420\3\2\2\2\u012b\u0422\3\2\2\2\u012d\u0424\3\2\2\2\u012f\u0429\3\2" + - "\2\2\u0131\u042f\3\2\2\2\u0133\u043d\3\2\2\2\u0135\u0136\7c\2\2\u0136" + - "\u0137\7d\2\2\u0137\u0138\7u\2\2\u0138\u0139\7v\2\2\u0139\u013a\7t\2\2" + - "\u013a\u013b\7c\2\2\u013b\u013c\7e\2\2\u013c\u013d\7v\2\2\u013d\4\3\2" + - "\2\2\u013e\u013f\7c\2\2\u013f\u0140\7u\2\2\u0140\u0141\7u\2\2\u0141\u0142" + - "\7g\2\2\u0142\u0143\7t\2\2\u0143\u0144\7v\2\2\u0144\6\3\2\2\2\u0145\u0146" + - "\7d\2\2\u0146\u0147\7q\2\2\u0147\u0148\7q\2\2\u0148\u0149\7n\2\2\u0149" + - "\u014a\7g\2\2\u014a\u014b\7c\2\2\u014b\u014c\7p\2\2\u014c\b\3\2\2\2\u014d" + - "\u014e\7d\2\2\u014e\u014f\7t\2\2\u014f\u0150\7g\2\2\u0150\u0151\7c\2\2" + - "\u0151\u0152\7m\2\2\u0152\n\3\2\2\2\u0153\u0154\7d\2\2\u0154\u0155\7{" + - "\2\2\u0155\u0156\7v\2\2\u0156\u0157\7g\2\2\u0157\f\3\2\2\2\u0158\u0159" + - "\7e\2\2\u0159\u015a\7c\2\2\u015a\u015b\7u\2\2\u015b\u015c\7g\2\2\u015c" + - "\16\3\2\2\2\u015d\u015e\7e\2\2\u015e\u015f\7c\2\2\u015f\u0160\7v\2\2\u0160" + - "\u0161\7e\2\2\u0161\u0162\7j\2\2\u0162\20\3\2\2\2\u0163\u0164\7e\2\2\u0164" + - "\u0165\7j\2\2\u0165\u0166\7c\2\2\u0166\u0167\7t\2\2\u0167\22\3\2\2\2\u0168" + - "\u0169\7e\2\2\u0169\u016a\7n\2\2\u016a\u016b\7c\2\2\u016b\u016c\7u\2\2" + - "\u016c\u016d\7u\2\2\u016d\24\3\2\2\2\u016e\u016f\7e\2\2\u016f\u0170\7" + - "q\2\2\u0170\u0171\7p\2\2\u0171\u0172\7u\2\2\u0172\u0173\7v\2\2\u0173\26" + - "\3\2\2\2\u0174\u0175\7e\2\2\u0175\u0176\7q\2\2\u0176\u0177\7p\2\2\u0177" + - "\u0178\7v\2\2\u0178\u0179\7k\2\2\u0179\u017a\7p\2\2\u017a\u017b\7w\2\2" + - "\u017b\u017c\7g\2\2\u017c\30\3\2\2\2\u017d\u017e\7f\2\2\u017e\u017f\7" + - "g\2\2\u017f\u0180\7h\2\2\u0180\u0181\7c\2\2\u0181\u0182\7w\2\2\u0182\u0183" + - "\7n\2\2\u0183\u0184\7v\2\2\u0184\32\3\2\2\2\u0185\u0186\7f\2\2\u0186\u0187" + - "\7q\2\2\u0187\34\3\2\2\2\u0188\u0189\7f\2\2\u0189\u018a\7q\2\2\u018a\u018b" + - "\7w\2\2\u018b\u018c\7d\2\2\u018c\u018d\7n\2\2\u018d\u018e\7g\2\2\u018e" + - "\36\3\2\2\2\u018f\u0190\7g\2\2\u0190\u0191\7n\2\2\u0191\u0192\7u\2\2\u0192" + - "\u0193\7g\2\2\u0193 \3\2\2\2\u0194\u0195\7g\2\2\u0195\u0196\7p\2\2\u0196" + - "\u0197\7w\2\2\u0197\u0198\7o\2\2\u0198\"\3\2\2\2\u0199\u019a\7g\2\2\u019a" + - "\u019b\7z\2\2\u019b\u019c\7v\2\2\u019c\u019d\7g\2\2\u019d\u019e\7p\2\2" + - "\u019e\u019f\7f\2\2\u019f\u01a0\7u\2\2\u01a0$\3\2\2\2\u01a1\u01a2\7h\2" + - "\2\u01a2\u01a3\7k\2\2\u01a3\u01a4\7p\2\2\u01a4\u01a5\7c\2\2\u01a5\u01a6" + - "\7n\2\2\u01a6&\3\2\2\2\u01a7\u01a8\7h\2\2\u01a8\u01a9\7k\2\2\u01a9\u01aa" + - "\7p\2\2\u01aa\u01ab\7c\2\2\u01ab\u01ac\7n\2\2\u01ac\u01ad\7n\2\2\u01ad" + - "\u01ae\7{\2\2\u01ae(\3\2\2\2\u01af\u01b0\7h\2\2\u01b0\u01b1\7n\2\2\u01b1" + - "\u01b2\7q\2\2\u01b2\u01b3\7c\2\2\u01b3\u01b4\7v\2\2\u01b4*\3\2\2\2\u01b5" + - "\u01b6\7h\2\2\u01b6\u01b7\7q\2\2\u01b7\u01b8\7t\2\2\u01b8,\3\2\2\2\u01b9" + - "\u01ba\7k\2\2\u01ba\u01bb\7h\2\2\u01bb.\3\2\2\2\u01bc\u01bd\7i\2\2\u01bd" + - "\u01be\7q\2\2\u01be\u01bf\7v\2\2\u01bf\u01c0\7q\2\2\u01c0\60\3\2\2\2\u01c1" + - "\u01c2\7k\2\2\u01c2\u01c3\7o\2\2\u01c3\u01c4\7r\2\2\u01c4\u01c5\7n\2\2" + - "\u01c5\u01c6\7g\2\2\u01c6\u01c7\7o\2\2\u01c7\u01c8\7g\2\2\u01c8\u01c9" + - "\7p\2\2\u01c9\u01ca\7v\2\2\u01ca\u01cb\7u\2\2\u01cb\62\3\2\2\2\u01cc\u01cd" + - "\7k\2\2\u01cd\u01ce\7o\2\2\u01ce\u01cf\7r\2\2\u01cf\u01d0\7q\2\2\u01d0" + - "\u01d1\7t\2\2\u01d1\u01d2\7v\2\2\u01d2\64\3\2\2\2\u01d3\u01d4\7k\2\2\u01d4" + - "\u01d5\7p\2\2\u01d5\u01d6\7u\2\2\u01d6\u01d7\7v\2\2\u01d7\u01d8\7c\2\2" + - "\u01d8\u01d9\7p\2\2\u01d9\u01da\7e\2\2\u01da\u01db\7g\2\2\u01db\u01dc" + - "\7q\2\2\u01dc\u01dd\7h\2\2\u01dd\66\3\2\2\2\u01de\u01df\7k\2\2\u01df\u01e0" + - "\7p\2\2\u01e0\u01e1\7v\2\2\u01e18\3\2\2\2\u01e2\u01e3\7k\2\2\u01e3\u01e4" + - "\7p\2\2\u01e4\u01e5\7v\2\2\u01e5\u01e6\7g\2\2\u01e6\u01e7\7t\2\2\u01e7" + - "\u01e8\7h\2\2\u01e8\u01e9\7c\2\2\u01e9\u01ea\7e\2\2\u01ea\u01eb\7g\2\2" + - "\u01eb:\3\2\2\2\u01ec\u01ed\7n\2\2\u01ed\u01ee\7q\2\2\u01ee\u01ef\7p\2" + - "\2\u01ef\u01f0\7i\2\2\u01f0<\3\2\2\2\u01f1\u01f2\7p\2\2\u01f2\u01f3\7" + - "c\2\2\u01f3\u01f4\7v\2\2\u01f4\u01f5\7k\2\2\u01f5\u01f6\7x\2\2\u01f6\u01f7" + - "\7g\2\2\u01f7>\3\2\2\2\u01f8\u01f9\7p\2\2\u01f9\u01fa\7g\2\2\u01fa\u01fb" + - "\7y\2\2\u01fb@\3\2\2\2\u01fc\u01fd\7r\2\2\u01fd\u01fe\7c\2\2\u01fe\u01ff" + - "\7e\2\2\u01ff\u0200\7m\2\2\u0200\u0201\7c\2\2\u0201\u0202\7i\2\2\u0202" + - "\u0203\7g\2\2\u0203B\3\2\2\2\u0204\u0205\7r\2\2\u0205\u0206\7t\2\2\u0206" + - "\u0207\7k\2\2\u0207\u0208\7x\2\2\u0208\u0209\7c\2\2\u0209\u020a\7v\2\2" + - "\u020a\u020b\7g\2\2\u020bD\3\2\2\2\u020c\u020d\7r\2\2\u020d\u020e\7t\2" + - "\2\u020e\u020f\7q\2\2\u020f\u0210\7v\2\2\u0210\u0211\7g\2\2\u0211\u0212" + - "\7e\2\2\u0212\u0213\7v\2\2\u0213\u0214\7g\2\2\u0214\u0215\7f\2\2\u0215" + - "F\3\2\2\2\u0216\u0217\7r\2\2\u0217\u0218\7w\2\2\u0218\u0219\7d\2\2\u0219" + - "\u021a\7n\2\2\u021a\u021b\7k\2\2\u021b\u021c\7e\2\2\u021cH\3\2\2\2\u021d" + - "\u021e\7t\2\2\u021e\u021f\7g\2\2\u021f\u0220\7v\2\2\u0220\u0221\7w\2\2" + - "\u0221\u0222\7t\2\2\u0222\u0223\7p\2\2\u0223J\3\2\2\2\u0224\u0225\7u\2" + - "\2\u0225\u0226\7j\2\2\u0226\u0227\7q\2\2\u0227\u0228\7t\2\2\u0228\u0229" + - "\7v\2\2\u0229L\3\2\2\2\u022a\u022b\7u\2\2\u022b\u022c\7v\2\2\u022c\u022d" + - "\7c\2\2\u022d\u022e\7v\2\2\u022e\u022f\7k\2\2\u022f\u0230\7e\2\2\u0230" + - "N\3\2\2\2\u0231\u0232\7u\2\2\u0232\u0233\7v\2\2\u0233\u0234\7t\2\2\u0234" + - "\u0235\7k\2\2\u0235\u0236\7e\2\2\u0236\u0237\7v\2\2\u0237\u0238\7h\2\2" + - "\u0238\u0239\7r\2\2\u0239P\3\2\2\2\u023a\u023b\7u\2\2\u023b\u023c\7w\2" + - "\2\u023c\u023d\7r\2\2\u023d\u023e\7g\2\2\u023e\u023f\7t\2\2\u023fR\3\2" + - "\2\2\u0240\u0241\7u\2\2\u0241\u0242\7y\2\2\u0242\u0243\7k\2\2\u0243\u0244" + - "\7v\2\2\u0244\u0245\7e\2\2\u0245\u0246\7j\2\2\u0246T\3\2\2\2\u0247\u0248" + - "\7u\2\2\u0248\u0249\7{\2\2\u0249\u024a\7p\2\2\u024a\u024b\7e\2\2\u024b" + - "\u024c\7j\2\2\u024c\u024d\7t\2\2\u024d\u024e\7q\2\2\u024e\u024f\7p\2\2" + - "\u024f\u0250\7k\2\2\u0250\u0251\7|\2\2\u0251\u0252\7g\2\2\u0252\u0253" + - "\7f\2\2\u0253V\3\2\2\2\u0254\u0255\7v\2\2\u0255\u0256\7j\2\2\u0256\u0257" + - "\7k\2\2\u0257\u0258\7u\2\2\u0258X\3\2\2\2\u0259\u025a\7v\2\2\u025a\u025b" + - "\7j\2\2\u025b\u025c\7t\2\2\u025c\u025d\7q\2\2\u025d\u025e\7y\2\2\u025e" + - "Z\3\2\2\2\u025f\u0260\7v\2\2\u0260\u0261\7j\2\2\u0261\u0262\7t\2\2\u0262" + - "\u0263\7q\2\2\u0263\u0264\7y\2\2\u0264\u0265\7u\2\2\u0265\\\3\2\2\2\u0266" + - "\u0267\7v\2\2\u0267\u0268\7t\2\2\u0268\u0269\7c\2\2\u0269\u026a\7p\2\2" + - "\u026a\u026b\7u\2\2\u026b\u026c\7k\2\2\u026c\u026d\7g\2\2\u026d\u026e" + - "\7p\2\2\u026e\u026f\7v\2\2\u026f^\3\2\2\2\u0270\u0271\7v\2\2\u0271\u0272" + - "\7t\2\2\u0272\u0273\7{\2\2\u0273`\3\2\2\2\u0274\u0275\7x\2\2\u0275\u0276" + - "\7q\2\2\u0276\u0277\7k\2\2\u0277\u0278\7f\2\2\u0278b\3\2\2\2\u0279\u027a" + - "\7x\2\2\u027a\u027b\7q\2\2\u027b\u027c\7n\2\2\u027c\u027d\7c\2\2\u027d" + - "\u027e\7v\2\2\u027e\u027f\7k\2\2\u027f\u0280\7n\2\2\u0280\u0281\7g\2\2" + - "\u0281d\3\2\2\2\u0282\u0283\7y\2\2\u0283\u0284\7j\2\2\u0284\u0285\7k\2" + - "\2\u0285\u0286\7n\2\2\u0286\u0287\7g\2\2\u0287f\3\2\2\2\u0288\u028d\5" + - "i\65\2\u0289\u028d\5k\66\2\u028a\u028d\5m\67\2\u028b\u028d\5o8\2\u028c" + - "\u0288\3\2\2\2\u028c\u0289\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028b\3\2" + - "\2\2\u028dh\3\2\2\2\u028e\u0290\5s:\2\u028f\u0291\5q9\2\u0290\u028f\3" + - "\2\2\2\u0290\u0291\3\2\2\2\u0291j\3\2\2\2\u0292\u0294\5\u0081A\2\u0293" + - "\u0295\5q9\2\u0294\u0293\3\2\2\2\u0294\u0295\3\2\2\2\u0295l\3\2\2\2\u0296" + - "\u0298\5\u008bF\2\u0297\u0299\5q9\2\u0298\u0297\3\2\2\2\u0298\u0299\3" + - "\2\2\2\u0299n\3\2\2\2\u029a\u029c\5\u0095K\2\u029b\u029d\5q9\2\u029c\u029b" + - "\3\2\2\2\u029c\u029d\3\2\2\2\u029dp\3\2\2\2\u029e\u029f\t\2\2\2\u029f" + - "r\3\2\2\2\u02a0\u02ab\7\62\2\2\u02a1\u02a8\5y=\2\u02a2\u02a4\5u;\2\u02a3" + - "\u02a2\3\2\2\2\u02a3\u02a4\3\2\2\2\u02a4\u02a9\3\2\2\2\u02a5\u02a6\5\177" + - "@\2\u02a6\u02a7\5u;\2\u02a7\u02a9\3\2\2\2\u02a8\u02a3\3\2\2\2\u02a8\u02a5" + - "\3\2\2\2\u02a9\u02ab\3\2\2\2\u02aa\u02a0\3\2\2\2\u02aa\u02a1\3\2\2\2\u02ab" + - "t\3\2\2\2\u02ac\u02b1\5w<\2\u02ad\u02af\5{>\2\u02ae\u02ad\3\2\2\2\u02ae" + - "\u02af\3\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b2\5w<\2\u02b1\u02ae\3\2\2" + - "\2\u02b1\u02b2\3\2\2\2\u02b2v\3\2\2\2\u02b3\u02b6\7\62\2\2\u02b4\u02b6" + - "\5y=\2\u02b5\u02b3\3\2\2\2\u02b5\u02b4\3\2\2\2\u02b6x\3\2\2\2\u02b7\u02b8" + - "\t\3\2\2\u02b8z\3\2\2\2\u02b9\u02bb\5}?\2\u02ba\u02b9\3\2\2\2\u02bb\u02bc" + - "\3\2\2\2\u02bc\u02ba\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd|\3\2\2\2\u02be" + - "\u02c1\5w<\2\u02bf\u02c1\7a\2\2\u02c0\u02be\3\2\2\2\u02c0\u02bf\3\2\2" + - "\2\u02c1~\3\2\2\2\u02c2\u02c4\7a\2\2\u02c3\u02c2\3\2\2\2\u02c4\u02c5\3" + - "\2\2\2\u02c5\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u0080\3\2\2\2\u02c7" + - "\u02c8\7\62\2\2\u02c8\u02c9\t\4\2\2\u02c9\u02ca\5\u0083B\2\u02ca\u0082" + - "\3\2\2\2\u02cb\u02d0\5\u0085C\2\u02cc\u02ce\5\u0087D\2\u02cd\u02cc\3\2" + - "\2\2\u02cd\u02ce\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d1\5\u0085C\2\u02d0" + - "\u02cd\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u0084\3\2\2\2\u02d2\u02d3\t\5" + - "\2\2\u02d3\u0086\3\2\2\2\u02d4\u02d6\5\u0089E\2\u02d5\u02d4\3\2\2\2\u02d6" + - "\u02d7\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8\u0088\3\2" + - "\2\2\u02d9\u02dc\5\u0085C\2\u02da\u02dc\7a\2\2\u02db\u02d9\3\2\2\2\u02db" + - "\u02da\3\2\2\2\u02dc\u008a\3\2\2\2\u02dd\u02df\7\62\2\2\u02de\u02e0\5" + - "\177@\2\u02df\u02de\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1" + - "\u02e2\5\u008dG\2\u02e2\u008c\3\2\2\2\u02e3\u02e8\5\u008fH\2\u02e4\u02e6" + - "\5\u0091I\2\u02e5\u02e4\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6\u02e7\3\2\2" + - "\2\u02e7\u02e9\5\u008fH\2\u02e8\u02e5\3\2\2\2\u02e8\u02e9\3\2\2\2\u02e9" + - "\u008e\3\2\2\2\u02ea\u02eb\t\6\2\2\u02eb\u0090\3\2\2\2\u02ec\u02ee\5\u0093" + - "J\2\u02ed\u02ec\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef\u02ed\3\2\2\2\u02ef" + - "\u02f0\3\2\2\2\u02f0\u0092\3\2\2\2\u02f1\u02f4\5\u008fH\2\u02f2\u02f4" + - "\7a\2\2\u02f3\u02f1\3\2\2\2\u02f3\u02f2\3\2\2\2\u02f4\u0094\3\2\2\2\u02f5" + - "\u02f6\7\62\2\2\u02f6\u02f7\t\7\2\2\u02f7\u02f8\5\u0097L\2\u02f8\u0096" + - "\3\2\2\2\u02f9\u02fe\5\u0099M\2\u02fa\u02fc\5\u009bN\2\u02fb\u02fa\3\2" + - "\2\2\u02fb\u02fc\3\2\2\2\u02fc\u02fd\3\2\2\2\u02fd\u02ff\5\u0099M\2\u02fe" + - "\u02fb\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0098\3\2\2\2\u0300\u0301\t\b" + - "\2\2\u0301\u009a\3\2\2\2\u0302\u0304\5\u009dO\2\u0303\u0302\3\2\2\2\u0304" + - "\u0305\3\2\2\2\u0305\u0303\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u009c\3\2" + - "\2\2\u0307\u030a\5\u0099M\2\u0308\u030a\7a\2\2\u0309\u0307\3\2\2\2\u0309" + - "\u0308\3\2\2\2\u030a\u009e\3\2\2\2\u030b\u030e\5\u00a1Q\2\u030c\u030e" + - "\5\u00adW\2\u030d\u030b\3\2\2\2\u030d\u030c\3\2\2\2\u030e\u00a0\3\2\2" + - "\2\u030f\u0310\5u;\2\u0310\u0312\7\60\2\2\u0311\u0313\5u;\2\u0312\u0311" + - "\3\2\2\2\u0312\u0313\3\2\2\2\u0313\u0315\3\2\2\2\u0314\u0316\5\u00a3R" + - "\2\u0315\u0314\3\2\2\2\u0315\u0316\3\2\2\2\u0316\u0318\3\2\2\2\u0317\u0319" + - "\5\u00abV\2\u0318\u0317\3\2\2\2\u0318\u0319\3\2\2\2\u0319\u032b\3\2\2" + - "\2\u031a\u031b\7\60\2\2\u031b\u031d\5u;\2\u031c\u031e\5\u00a3R\2\u031d" + - "\u031c\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u0320\3\2\2\2\u031f\u0321\5\u00ab" + - "V\2\u0320\u031f\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u032b\3\2\2\2\u0322" + - "\u0323\5u;\2\u0323\u0325\5\u00a3R\2\u0324\u0326\5\u00abV\2\u0325\u0324" + - "\3\2\2\2\u0325\u0326\3\2\2\2\u0326\u032b\3\2\2\2\u0327\u0328\5u;\2\u0328" + - "\u0329\5\u00abV\2\u0329\u032b\3\2\2\2\u032a\u030f\3\2\2\2\u032a\u031a" + - "\3\2\2\2\u032a\u0322\3\2\2\2\u032a\u0327\3\2\2\2\u032b\u00a2\3\2\2\2\u032c" + - "\u032d\5\u00a5S\2\u032d\u032e\5\u00a7T\2\u032e\u00a4\3\2\2\2\u032f\u0330" + - "\t\t\2\2\u0330\u00a6\3\2\2\2\u0331\u0333\5\u00a9U\2\u0332\u0331\3\2\2" + - "\2\u0332\u0333\3\2\2\2\u0333\u0334\3\2\2\2\u0334\u0335\5u;\2\u0335\u00a8" + - "\3\2\2\2\u0336\u0337\t\n\2\2\u0337\u00aa\3\2\2\2\u0338\u0339\t\13\2\2" + - "\u0339\u00ac\3\2\2\2\u033a\u033b\5\u00afX\2\u033b\u033d\5\u00b1Y\2\u033c" + - "\u033e\5\u00abV\2\u033d\u033c\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u00ae" + - "\3\2\2\2\u033f\u0341\5\u0081A\2\u0340\u0342\7\60\2\2\u0341\u0340\3\2\2" + - "\2\u0341\u0342\3\2\2\2\u0342\u034b\3\2\2\2\u0343\u0344\7\62\2\2\u0344" + - "\u0346\t\4\2\2\u0345\u0347\5\u0083B\2\u0346\u0345\3\2\2\2\u0346\u0347" + - "\3\2\2\2\u0347\u0348\3\2\2\2\u0348\u0349\7\60\2\2\u0349\u034b\5\u0083" + - "B\2\u034a\u033f\3\2\2\2\u034a\u0343\3\2\2\2\u034b\u00b0\3\2\2\2\u034c" + - "\u034d\5\u00b3Z\2\u034d\u034e\5\u00a7T\2\u034e\u00b2\3\2\2\2\u034f\u0350" + - "\t\f\2\2\u0350\u00b4\3\2\2\2\u0351\u0352\7v\2\2\u0352\u0353\7t\2\2\u0353" + - "\u0354\7w\2\2\u0354\u035b\7g\2\2\u0355\u0356\7h\2\2\u0356\u0357\7c\2\2" + - "\u0357\u0358\7n\2\2\u0358\u0359\7u\2\2\u0359\u035b\7g\2\2\u035a\u0351" + - "\3\2\2\2\u035a\u0355\3\2\2\2\u035b\u00b6\3\2\2\2\u035c\u035d\7)\2\2\u035d" + - "\u035e\5\u00b9]\2\u035e\u035f\7)\2\2\u035f\u0365\3\2\2\2\u0360\u0361\7" + - ")\2\2\u0361\u0362\5\u00c1a\2\u0362\u0363\7)\2\2\u0363\u0365\3\2\2\2\u0364" + - "\u035c\3\2\2\2\u0364\u0360\3\2\2\2\u0365\u00b8\3\2\2\2\u0366\u0367\n\r" + - "\2\2\u0367\u00ba\3\2\2\2\u0368\u036a\7$\2\2\u0369\u036b\5\u00bd_\2\u036a" + - "\u0369\3\2\2\2\u036a\u036b\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036d\7$" + - "\2\2\u036d\u00bc\3\2\2\2\u036e\u0370\5\u00bf`\2\u036f\u036e\3\2\2\2\u0370" + - "\u0371\3\2\2\2\u0371\u036f\3\2\2\2\u0371\u0372\3\2\2\2\u0372\u00be\3\2" + - "\2\2\u0373\u0376\n\16\2\2\u0374\u0376\5\u00c1a\2\u0375\u0373\3\2\2\2\u0375" + - "\u0374\3\2\2\2\u0376\u00c0\3\2\2\2\u0377\u0378\7^\2\2\u0378\u037c\t\17" + - "\2\2\u0379\u037c\5\u00c3b\2\u037a\u037c\5\u00c7d\2\u037b\u0377\3\2\2\2" + - "\u037b\u0379\3\2\2\2\u037b\u037a\3\2\2\2\u037c\u00c2\3\2\2\2\u037d\u037e" + - "\7^\2\2\u037e\u0389\5\u008fH\2\u037f\u0380\7^\2\2\u0380\u0381\5\u008f" + - "H\2\u0381\u0382\5\u008fH\2\u0382\u0389\3\2\2\2\u0383\u0384\7^\2\2\u0384" + - "\u0385\5\u00c5c\2\u0385\u0386\5\u008fH\2\u0386\u0387\5\u008fH\2\u0387" + - "\u0389\3\2\2\2\u0388\u037d\3\2\2\2\u0388\u037f\3\2\2\2\u0388\u0383\3\2" + - "\2\2\u0389\u00c4\3\2\2\2\u038a\u038b\t\20\2\2\u038b\u00c6\3\2\2\2\u038c" + - "\u038d\7^\2\2\u038d\u038e\7w\2\2\u038e\u038f\5\u0085C\2\u038f\u0390\5" + - "\u0085C\2\u0390\u0391\5\u0085C\2\u0391\u0392\5\u0085C\2\u0392\u00c8\3" + - "\2\2\2\u0393\u0394\7p\2\2\u0394\u0395\7w\2\2\u0395\u0396\7n\2\2\u0396" + - "\u0397\7n\2\2\u0397\u00ca\3\2\2\2\u0398\u0399\7*\2\2\u0399\u00cc\3\2\2" + - "\2\u039a\u039b\7+\2\2\u039b\u00ce\3\2\2\2\u039c\u039d\7}\2\2\u039d\u00d0" + - "\3\2\2\2\u039e\u039f\7\177\2\2\u039f\u00d2\3\2\2\2\u03a0\u03a1\7]\2\2" + - "\u03a1\u00d4\3\2\2\2\u03a2\u03a3\7_\2\2\u03a3\u00d6\3\2\2\2\u03a4\u03a5" + - "\7=\2\2\u03a5\u00d8\3\2\2\2\u03a6\u03a7\7.\2\2\u03a7\u00da\3\2\2\2\u03a8" + - "\u03a9\7\60\2\2\u03a9\u00dc\3\2\2\2\u03aa\u03ab\7?\2\2\u03ab\u00de\3\2" + - "\2\2\u03ac\u03ad\7@\2\2\u03ad\u00e0\3\2\2\2\u03ae\u03af\7>\2\2\u03af\u00e2" + - "\3\2\2\2\u03b0\u03b1\7#\2\2\u03b1\u00e4\3\2\2\2\u03b2\u03b3\7\u0080\2" + - "\2\u03b3\u00e6\3\2\2\2\u03b4\u03b5\7A\2\2\u03b5\u00e8\3\2\2\2\u03b6\u03b7" + - "\7<\2\2\u03b7\u00ea\3\2\2\2\u03b8\u03b9\7?\2\2\u03b9\u03ba\7?\2\2\u03ba" + - "\u00ec\3\2\2\2\u03bb\u03bc\7>\2\2\u03bc\u03bd\7?\2\2\u03bd\u00ee\3\2\2" + - "\2\u03be\u03bf\7@\2\2\u03bf\u03c0\7?\2\2\u03c0\u00f0\3\2\2\2\u03c1\u03c2" + - "\7#\2\2\u03c2\u03c3\7?\2\2\u03c3\u00f2\3\2\2\2\u03c4\u03c5\7(\2\2\u03c5" + - "\u03c6\7(\2\2\u03c6\u00f4\3\2\2\2\u03c7\u03c8\7~\2\2\u03c8\u03c9\7~\2" + - "\2\u03c9\u00f6\3\2\2\2\u03ca\u03cb\7-\2\2\u03cb\u03cc\7-\2\2\u03cc\u00f8" + - "\3\2\2\2\u03cd\u03ce\7/\2\2\u03ce\u03cf\7/\2\2\u03cf\u00fa\3\2\2\2\u03d0" + - "\u03d1\7-\2\2\u03d1\u00fc\3\2\2\2\u03d2\u03d3\7/\2\2\u03d3\u00fe\3\2\2" + - "\2\u03d4\u03d5\7,\2\2\u03d5\u0100\3\2\2\2\u03d6\u03d7\7\61\2\2\u03d7\u0102" + - "\3\2\2\2\u03d8\u03d9\7(\2\2\u03d9\u0104\3\2\2\2\u03da\u03db\7~\2\2\u03db" + - "\u0106\3\2\2\2\u03dc\u03dd\7`\2\2\u03dd\u0108\3\2\2\2\u03de\u03df\7\'" + - "\2\2\u03df\u010a\3\2\2\2\u03e0\u03e1\7/\2\2\u03e1\u03e2\7@\2\2\u03e2\u010c" + - "\3\2\2\2\u03e3\u03e4\7<\2\2\u03e4\u03e5\7<\2\2\u03e5\u010e\3\2\2\2\u03e6" + - "\u03e7\7-\2\2\u03e7\u03e8\7?\2\2\u03e8\u0110\3\2\2\2\u03e9\u03ea\7/\2" + - "\2\u03ea\u03eb\7?\2\2\u03eb\u0112\3\2\2\2\u03ec\u03ed\7,\2\2\u03ed\u03ee" + - "\7?\2\2\u03ee\u0114\3\2\2\2\u03ef\u03f0\7\61\2\2\u03f0\u03f1\7?\2\2\u03f1" + - "\u0116\3\2\2\2\u03f2\u03f3\7(\2\2\u03f3\u03f4\7?\2\2\u03f4\u0118\3\2\2" + - "\2\u03f5\u03f6\7~\2\2\u03f6\u03f7\7?\2\2\u03f7\u011a\3\2\2\2\u03f8\u03f9" + - "\7`\2\2\u03f9\u03fa\7?\2\2\u03fa\u011c\3\2\2\2\u03fb\u03fc\7\'\2\2\u03fc" + - "\u03fd\7?\2\2\u03fd\u011e\3\2\2\2\u03fe\u03ff\7>\2\2\u03ff\u0400\7>\2" + - "\2\u0400\u0401\7?\2\2\u0401\u0120\3\2\2\2\u0402\u0403\7@\2\2\u0403\u0404" + - "\7@\2\2\u0404\u0405\7?\2\2\u0405\u0122\3\2\2\2\u0406\u0407\7@\2\2\u0407" + - "\u0408\7@\2\2\u0408\u0409\7@\2\2\u0409\u040a\7?\2\2\u040a\u0124\3\2\2" + - "\2\u040b\u040f\5\u0127\u0094\2\u040c\u040e\5\u0129\u0095\2\u040d\u040c" + - "\3\2\2\2\u040e\u0411\3\2\2\2\u040f\u040d\3\2\2\2\u040f\u0410\3\2\2\2\u0410" + - "\u0126\3\2\2\2\u0411\u040f\3\2\2\2\u0412\u0419\t\21\2\2\u0413\u0414\n" + - "\22\2\2\u0414\u0419\6\u0094\2\2\u0415\u0416\t\23\2\2\u0416\u0417\t\24" + - "\2\2\u0417\u0419\6\u0094\3\2\u0418\u0412\3\2\2\2\u0418\u0413\3\2\2\2\u0418" + - "\u0415\3\2\2\2\u0419\u0128\3\2\2\2\u041a\u0421\t\25\2\2\u041b\u041c\n" + - "\22\2\2\u041c\u0421\6\u0095\4\2\u041d\u041e\t\23\2\2\u041e\u041f\t\24" + - "\2\2\u041f\u0421\6\u0095\5\2\u0420\u041a\3\2\2\2\u0420\u041b\3\2\2\2\u0420" + - "\u041d\3\2\2\2\u0421\u012a\3\2\2\2\u0422\u0423\7B\2\2\u0423\u012c\3\2" + - "\2\2\u0424\u0425\7\60\2\2\u0425\u0426\7\60\2\2\u0426\u0427\7\60\2\2\u0427" + - "\u012e\3\2\2\2\u0428\u042a\t\26\2\2\u0429\u0428\3\2\2\2\u042a\u042b\3" + - "\2\2\2\u042b\u0429\3\2\2\2\u042b\u042c\3\2\2\2\u042c\u042d\3\2\2\2\u042d" + - "\u042e\b\u0098\2\2\u042e\u0130\3\2\2\2\u042f\u0430\7\61\2\2\u0430\u0431" + - "\7,\2\2\u0431\u0435\3\2\2\2\u0432\u0434\13\2\2\2\u0433\u0432\3\2\2\2\u0434" + - "\u0437\3\2\2\2\u0435\u0436\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0438\3\2" + - "\2\2\u0437\u0435\3\2\2\2\u0438\u0439\7,\2\2\u0439\u043a\7\61\2\2\u043a" + - "\u043b\3\2\2\2\u043b\u043c\b\u0099\2\2\u043c\u0132\3\2\2\2\u043d\u043e" + - "\7\61\2\2\u043e\u043f\7\61\2\2\u043f\u0443\3\2\2\2\u0440\u0442\n\27\2" + - "\2\u0441\u0440\3\2\2\2\u0442\u0445\3\2\2\2\u0443\u0441\3\2\2\2\u0443\u0444" + - "\3\2\2\2\u0444\u0446\3\2\2\2\u0445\u0443\3\2\2\2\u0446\u0447\b\u009a\2" + - "\2\u0447\u0134\3\2\2\28\2\u028c\u0290\u0294\u0298\u029c\u02a3\u02a8\u02aa" + - "\u02ae\u02b1\u02b5\u02bc\u02c0\u02c5\u02cd\u02d0\u02d7\u02db\u02df\u02e5" + - "\u02e8\u02ef\u02f3\u02fb\u02fe\u0305\u0309\u030d\u0312\u0315\u0318\u031d" + - "\u0320\u0325\u032a\u0332\u033d\u0341\u0346\u034a\u035a\u0364\u036a\u0371" + - "\u0375\u037b\u0388\u040f\u0418\u0420\u042b\u0435\u0443\3\b\2\2"; - public static final ATN _ATN = - new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - - static { - } -} diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Parser.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Parser.java deleted file mode 100644 index e2bbd32..0000000 --- a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Parser.java +++ /dev/null @@ -1,19733 +0,0 @@ -// Generated from Java8.g4 by ANTLR 4.5 -package org.nuiton.config.plugin.parser.java; - -/* - * #%L - * Nuiton Config :: Maven plugin - * %% - * Copyright (C) 2016 Code Lutin, Tony Chemit - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ - -import org.antlr.v4.runtime.FailedPredicateException; -import org.antlr.v4.runtime.NoViableAltException; -import org.antlr.v4.runtime.Parser; -import org.antlr.v4.runtime.ParserRuleContext; -import org.antlr.v4.runtime.RecognitionException; -import org.antlr.v4.runtime.RuleContext; -import org.antlr.v4.runtime.RuleVersion; -import org.antlr.v4.runtime.TokenStream; -import org.antlr.v4.runtime.Vocabulary; -import org.antlr.v4.runtime.VocabularyImpl; -import org.antlr.v4.runtime.atn.ATN; -import org.antlr.v4.runtime.atn.ATNDeserializer; -import org.antlr.v4.runtime.atn.ParserATNSimulator; -import org.antlr.v4.runtime.misc.NotNull; -import org.antlr.v4.runtime.misc.Utils; -import org.antlr.v4.runtime.tree.ParseTreeVisitor; -import org.antlr.v4.runtime.tree.TerminalNode; - -import java.util.List; - -public class Java8Parser extends Parser { - public static final int - ABSTRACT = 1, ASSERT = 2, BOOLEAN = 3, BREAK = 4, BYTE = 5, CASE = 6, CATCH = 7, CHAR = 8, - CLASS = 9, CONST = 10, CONTINUE = 11, DEFAULT = 12, DO = 13, DOUBLE = 14, ELSE = 15, - ENUM = 16, EXTENDS = 17, FINAL = 18, FINALLY = 19, FLOAT = 20, FOR = 21, IF = 22, GOTO = 23, - IMPLEMENTS = 24, IMPORT = 25, INSTANCEOF = 26, INT = 27, INTERFACE = 28, LONG = 29, - NATIVE = 30, NEW = 31, PACKAGE = 32, PRIVATE = 33, PROTECTED = 34, PUBLIC = 35, RETURN = 36, - SHORT = 37, STATIC = 38, STRICTFP = 39, SUPER = 40, SWITCH = 41, SYNCHRONIZED = 42, - THIS = 43, THROW = 44, THROWS = 45, TRANSIENT = 46, TRY = 47, VOID = 48, VOLATILE = 49, - WHILE = 50, IntegerLiteral = 51, FloatingPointLiteral = 52, BooleanLiteral = 53, - CharacterLiteral = 54, StringLiteral = 55, NullLiteral = 56, LPAREN = 57, RPAREN = 58, - LBRACE = 59, RBRACE = 60, LBRACK = 61, RBRACK = 62, SEMI = 63, COMMA = 64, DOT = 65, - ASSIGN = 66, GT = 67, LT = 68, BANG = 69, TILDE = 70, QUESTION = 71, COLON = 72, EQUAL = 73, - LE = 74, GE = 75, NOTEQUAL = 76, AND = 77, OR = 78, INC = 79, DEC = 80, ADD = 81, SUB = 82, - MUL = 83, DIV = 84, BITAND = 85, BITOR = 86, CARET = 87, MOD = 88, ARROW = 89, COLONCOLON = 90, - ADD_ASSIGN = 91, SUB_ASSIGN = 92, MUL_ASSIGN = 93, DIV_ASSIGN = 94, AND_ASSIGN = 95, - OR_ASSIGN = 96, XOR_ASSIGN = 97, MOD_ASSIGN = 98, LSHIFT_ASSIGN = 99, RSHIFT_ASSIGN = 100, - URSHIFT_ASSIGN = 101, Identifier = 102, AT = 103, ELLIPSIS = 104, WS = 105, COMMENT = 106, - LINE_COMMENT = 107; - public static final int - RULE_literal = 0, RULE_type = 1, RULE_primitiveType = 2, RULE_numericType = 3, - RULE_integralType = 4, RULE_floatingPointType = 5, RULE_referenceType = 6, - RULE_classOrInterfaceType = 7, RULE_classType = 8, RULE_classType_lf_classOrInterfaceType = 9, - RULE_classType_lfno_classOrInterfaceType = 10, RULE_interfaceType = 11, - RULE_interfaceType_lf_classOrInterfaceType = 12, RULE_interfaceType_lfno_classOrInterfaceType = 13, - RULE_typeVariable = 14, RULE_arrayType = 15, RULE_dims = 16, RULE_typeParameter = 17, - RULE_typeParameterModifier = 18, RULE_typeBound = 19, RULE_additionalBound = 20, - RULE_typeArguments = 21, RULE_typeArgumentList = 22, RULE_typeArgument = 23, - RULE_wildcard = 24, RULE_wildcardBounds = 25, RULE_packageName = 26, RULE_typeName = 27, - RULE_packageOrTypeName = 28, RULE_expressionName = 29, RULE_methodName = 30, - RULE_ambiguousName = 31, RULE_compilationUnit = 32, RULE_packageDeclaration = 33, - RULE_packageModifier = 34, RULE_importDeclaration = 35, RULE_singleTypeImportDeclaration = 36, - RULE_typeImportOnDemandDeclaration = 37, RULE_singleStaticImportDeclaration = 38, - RULE_staticImportOnDemandDeclaration = 39, RULE_typeDeclaration = 40, - RULE_classDeclaration = 41, RULE_normalClassDeclaration = 42, RULE_classModifier = 43, - RULE_typeParameters = 44, RULE_typeParameterList = 45, RULE_superclass = 46, - RULE_superinterfaces = 47, RULE_interfaceTypeList = 48, RULE_classBody = 49, - RULE_classBodyDeclaration = 50, RULE_classMemberDeclaration = 51, RULE_fieldDeclaration = 52, - RULE_fieldModifier = 53, RULE_variableDeclaratorList = 54, RULE_variableDeclarator = 55, - RULE_variableDeclaratorId = 56, RULE_variableInitializer = 57, RULE_unannType = 58, - RULE_unannPrimitiveType = 59, RULE_unannReferenceType = 60, RULE_unannClassOrInterfaceType = 61, - RULE_unannClassType = 62, RULE_unannClassType_lf_unannClassOrInterfaceType = 63, - RULE_unannClassType_lfno_unannClassOrInterfaceType = 64, RULE_unannInterfaceType = 65, - RULE_unannInterfaceType_lf_unannClassOrInterfaceType = 66, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType = 67, - RULE_unannTypeVariable = 68, RULE_unannArrayType = 69, RULE_methodDeclaration = 70, - RULE_methodModifier = 71, RULE_methodHeader = 72, RULE_result = 73, RULE_methodDeclarator = 74, - RULE_formalParameterList = 75, RULE_formalParameters = 76, RULE_formalParameter = 77, - RULE_variableModifier = 78, RULE_lastFormalParameter = 79, RULE_receiverParameter = 80, - RULE_throws_ = 81, RULE_exceptionTypeList = 82, RULE_exceptionType = 83, - RULE_methodBody = 84, RULE_instanceInitializer = 85, RULE_staticInitializer = 86, - RULE_constructorDeclaration = 87, RULE_constructorModifier = 88, RULE_constructorDeclarator = 89, - RULE_simpleTypeName = 90, RULE_constructorBody = 91, RULE_explicitConstructorInvocation = 92, - RULE_enumDeclaration = 93, RULE_enumBody = 94, RULE_enumConstantList = 95, - RULE_enumConstant = 96, RULE_enumConstantModifier = 97, RULE_enumBodyDeclarations = 98, - RULE_interfaceDeclaration = 99, RULE_normalInterfaceDeclaration = 100, - RULE_interfaceModifier = 101, RULE_extendsInterfaces = 102, RULE_interfaceBody = 103, - RULE_interfaceMemberDeclaration = 104, RULE_constantDeclaration = 105, - RULE_constantModifier = 106, RULE_interfaceMethodDeclaration = 107, RULE_interfaceMethodModifier = 108, - RULE_annotationTypeDeclaration = 109, RULE_annotationTypeBody = 110, RULE_annotationTypeMemberDeclaration = 111, - RULE_annotationTypeElementDeclaration = 112, RULE_annotationTypeElementModifier = 113, - RULE_defaultValue = 114, RULE_annotation = 115, RULE_normalAnnotation = 116, - RULE_elementValuePairList = 117, RULE_elementValuePair = 118, RULE_elementValue = 119, - RULE_elementValueArrayInitializer = 120, RULE_elementValueList = 121, - RULE_markerAnnotation = 122, RULE_singleElementAnnotation = 123, RULE_arrayInitializer = 124, - RULE_variableInitializerList = 125, RULE_block = 126, RULE_blockStatements = 127, - RULE_blockStatement = 128, RULE_localVariableDeclarationStatement = 129, - RULE_localVariableDeclaration = 130, RULE_statement = 131, RULE_statementNoShortIf = 132, - RULE_statementWithoutTrailingSubstatement = 133, RULE_emptyStatement = 134, - RULE_labeledStatement = 135, RULE_labeledStatementNoShortIf = 136, RULE_expressionStatement = 137, - RULE_statementExpression = 138, RULE_ifThenStatement = 139, RULE_ifThenElseStatement = 140, - RULE_ifThenElseStatementNoShortIf = 141, RULE_assertStatement = 142, RULE_switchStatement = 143, - RULE_switchBlock = 144, RULE_switchBlockStatementGroup = 145, RULE_switchLabels = 146, - RULE_switchLabel = 147, RULE_enumConstantName = 148, RULE_whileStatement = 149, - RULE_whileStatementNoShortIf = 150, RULE_doStatement = 151, RULE_forStatement = 152, - RULE_forStatementNoShortIf = 153, RULE_basicForStatement = 154, RULE_basicForStatementNoShortIf = 155, - RULE_forInit = 156, RULE_forUpdate = 157, RULE_statementExpressionList = 158, - RULE_enhancedForStatement = 159, RULE_enhancedForStatementNoShortIf = 160, - RULE_breakStatement = 161, RULE_continueStatement = 162, RULE_returnStatement = 163, - RULE_throwStatement = 164, RULE_synchronizedStatement = 165, RULE_tryStatement = 166, - RULE_catches = 167, RULE_catchClause = 168, RULE_catchFormalParameter = 169, - RULE_catchType = 170, RULE_finally_ = 171, RULE_tryWithResourcesStatement = 172, - RULE_resourceSpecification = 173, RULE_resourceList = 174, RULE_resource = 175, - RULE_primary = 176, RULE_primaryNoNewArray = 177, RULE_primaryNoNewArray_lf_arrayAccess = 178, - RULE_primaryNoNewArray_lfno_arrayAccess = 179, RULE_primaryNoNewArray_lf_primary = 180, - RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary = 181, RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary = 182, - RULE_primaryNoNewArray_lfno_primary = 183, RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary = 184, - RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary = 185, - RULE_classInstanceCreationExpression = 186, RULE_classInstanceCreationExpression_lf_primary = 187, - RULE_classInstanceCreationExpression_lfno_primary = 188, RULE_typeArgumentsOrDiamond = 189, - RULE_fieldAccess = 190, RULE_fieldAccess_lf_primary = 191, RULE_fieldAccess_lfno_primary = 192, - RULE_arrayAccess = 193, RULE_arrayAccess_lf_primary = 194, RULE_arrayAccess_lfno_primary = 195, - RULE_methodInvocation = 196, RULE_methodInvocation_lf_primary = 197, RULE_methodInvocation_lfno_primary = 198, - RULE_argumentList = 199, RULE_methodReference = 200, RULE_methodReference_lf_primary = 201, - RULE_methodReference_lfno_primary = 202, RULE_arrayCreationExpression = 203, - RULE_dimExprs = 204, RULE_dimExpr = 205, RULE_constantExpression = 206, - RULE_expression = 207, RULE_lambdaExpression = 208, RULE_lambdaParameters = 209, - RULE_inferredFormalParameterList = 210, RULE_lambdaBody = 211, RULE_assignmentExpression = 212, - RULE_assignment = 213, RULE_leftHandSide = 214, RULE_assignmentOperator = 215, - RULE_conditionalExpression = 216, RULE_conditionalOrExpression = 217, - RULE_conditionalAndExpression = 218, RULE_inclusiveOrExpression = 219, - RULE_exclusiveOrExpression = 220, RULE_andExpression = 221, RULE_equalityExpression = 222, - RULE_relationalExpression = 223, RULE_shiftExpression = 224, RULE_additiveExpression = 225, - RULE_multiplicativeExpression = 226, RULE_unaryExpression = 227, RULE_preIncrementExpression = 228, - RULE_preDecrementExpression = 229, RULE_unaryExpressionNotPlusMinus = 230, - RULE_postfixExpression = 231, RULE_postIncrementExpression = 232, RULE_postIncrementExpression_lf_postfixExpression = 233, - RULE_postDecrementExpression = 234, RULE_postDecrementExpression_lf_postfixExpression = 235, - RULE_castExpression = 236; - public static final String[] ruleNames = { - "literal", "type", "primitiveType", "numericType", "integralType", "floatingPointType", - "referenceType", "classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType", - "classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType", - "interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType", - "dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound", - "typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds", - "packageName", "typeName", "packageOrTypeName", "expressionName", "methodName", - "ambiguousName", "compilationUnit", "packageDeclaration", "packageModifier", - "importDeclaration", "singleTypeImportDeclaration", "typeImportOnDemandDeclaration", - "singleStaticImportDeclaration", "staticImportOnDemandDeclaration", "typeDeclaration", - "classDeclaration", "normalClassDeclaration", "classModifier", "typeParameters", - "typeParameterList", "superclass", "superinterfaces", "interfaceTypeList", - "classBody", "classBodyDeclaration", "classMemberDeclaration", "fieldDeclaration", - "fieldModifier", "variableDeclaratorList", "variableDeclarator", "variableDeclaratorId", - "variableInitializer", "unannType", "unannPrimitiveType", "unannReferenceType", - "unannClassOrInterfaceType", "unannClassType", "unannClassType_lf_unannClassOrInterfaceType", - "unannClassType_lfno_unannClassOrInterfaceType", "unannInterfaceType", - "unannInterfaceType_lf_unannClassOrInterfaceType", "unannInterfaceType_lfno_unannClassOrInterfaceType", - "unannTypeVariable", "unannArrayType", "methodDeclaration", "methodModifier", - "methodHeader", "result", "methodDeclarator", "formalParameterList", "formalParameters", - "formalParameter", "variableModifier", "lastFormalParameter", "receiverParameter", - "throws_", "exceptionTypeList", "exceptionType", "methodBody", "instanceInitializer", - "staticInitializer", "constructorDeclaration", "constructorModifier", - "constructorDeclarator", "simpleTypeName", "constructorBody", "explicitConstructorInvocation", - "enumDeclaration", "enumBody", "enumConstantList", "enumConstant", "enumConstantModifier", - "enumBodyDeclarations", "interfaceDeclaration", "normalInterfaceDeclaration", - "interfaceModifier", "extendsInterfaces", "interfaceBody", "interfaceMemberDeclaration", - "constantDeclaration", "constantModifier", "interfaceMethodDeclaration", - "interfaceMethodModifier", "annotationTypeDeclaration", "annotationTypeBody", - "annotationTypeMemberDeclaration", "annotationTypeElementDeclaration", - "annotationTypeElementModifier", "defaultValue", "annotation", "normalAnnotation", - "elementValuePairList", "elementValuePair", "elementValue", "elementValueArrayInitializer", - "elementValueList", "markerAnnotation", "singleElementAnnotation", "arrayInitializer", - "variableInitializerList", "block", "blockStatements", "blockStatement", - "localVariableDeclarationStatement", "localVariableDeclaration", "statement", - "statementNoShortIf", "statementWithoutTrailingSubstatement", "emptyStatement", - "labeledStatement", "labeledStatementNoShortIf", "expressionStatement", - "statementExpression", "ifThenStatement", "ifThenElseStatement", "ifThenElseStatementNoShortIf", - "assertStatement", "switchStatement", "switchBlock", "switchBlockStatementGroup", - "switchLabels", "switchLabel", "enumConstantName", "whileStatement", "whileStatementNoShortIf", - "doStatement", "forStatement", "forStatementNoShortIf", "basicForStatement", - "basicForStatementNoShortIf", "forInit", "forUpdate", "statementExpressionList", - "enhancedForStatement", "enhancedForStatementNoShortIf", "breakStatement", - "continueStatement", "returnStatement", "throwStatement", "synchronizedStatement", - "tryStatement", "catches", "catchClause", "catchFormalParameter", "catchType", - "finally_", "tryWithResourcesStatement", "resourceSpecification", "resourceList", - "resource", "primary", "primaryNoNewArray", "primaryNoNewArray_lf_arrayAccess", - "primaryNoNewArray_lfno_arrayAccess", "primaryNoNewArray_lf_primary", - "primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary", "primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary", - "primaryNoNewArray_lfno_primary", "primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary", - "primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary", "classInstanceCreationExpression", - "classInstanceCreationExpression_lf_primary", "classInstanceCreationExpression_lfno_primary", - "typeArgumentsOrDiamond", "fieldAccess", "fieldAccess_lf_primary", "fieldAccess_lfno_primary", - "arrayAccess", "arrayAccess_lf_primary", "arrayAccess_lfno_primary", "methodInvocation", - "methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList", - "methodReference", "methodReference_lf_primary", "methodReference_lfno_primary", - "arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression", - "expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList", - "lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator", - "conditionalExpression", "conditionalOrExpression", "conditionalAndExpression", - "inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression", - "relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression", - "unaryExpression", "preIncrementExpression", "preDecrementExpression", - "unaryExpressionNotPlusMinus", "postfixExpression", "postIncrementExpression", - "postIncrementExpression_lf_postfixExpression", "postDecrementExpression", - "postDecrementExpression_lf_postfixExpression", "castExpression" - }; - - private static final String[] _LITERAL_NAMES = { - null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", - "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", - "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", - "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", - "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", - "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", - "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", - "'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, - null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", - "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", - "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", - "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", - "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", - "'>>>='", null, "'@'", "'...'" - }; - private static final String[] _SYMBOLIC_NAMES = { - null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", - "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", - "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", - "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", - "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", - "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", - "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "FloatingPointLiteral", - "BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral", - "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", - "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", - "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", - "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", "ADD_ASSIGN", - "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", - "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", - "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" - }; - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); - - /** - * @deprecated Use {@link #VOCABULARY} instead. - */ - @Deprecated - public static final String[] tokenNames; - - static { - tokenNames = new String[_SYMBOLIC_NAMES.length]; - for (int i = 0; i < tokenNames.length; i++) { - tokenNames[i] = VOCABULARY.getLiteralName(i); - if (tokenNames[i] == null) { - tokenNames[i] = VOCABULARY.getSymbolicName(i); - } - - if (tokenNames[i] == null) { - tokenNames[i] = "<INVALID>"; - } - } - } - - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } - - @Override - @NotNull - public Vocabulary getVocabulary() { - return VOCABULARY; - } - - @Override - public String getGrammarFileName() { - return "Java8.g4"; - } - - @Override - public String[] getRuleNames() { - return ruleNames; - } - - @Override - public String getSerializedATN() { - return _serializedATN; - } - - public Java8Parser(TokenStream input) { - super(input); - _interp = new ParserATNSimulator(this, _ATN); - } - - public static class LiteralContext extends ParserRuleContext { - public TerminalNode IntegerLiteral() { - return getToken(Java8Parser.IntegerLiteral, 0); - } - - public TerminalNode FloatingPointLiteral() { - return getToken(Java8Parser.FloatingPointLiteral, 0); - } - - public TerminalNode BooleanLiteral() { - return getToken(Java8Parser.BooleanLiteral, 0); - } - - public TerminalNode CharacterLiteral() { - return getToken(Java8Parser.CharacterLiteral, 0); - } - - public TerminalNode StringLiteral() { - return getToken(Java8Parser.StringLiteral, 0); - } - - public TerminalNode NullLiteral() { - return getToken(Java8Parser.NullLiteral, 0); - } - - public LiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_literal; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitLiteral(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final LiteralContext literal() throws RecognitionException { - LiteralContext _localctx = new LiteralContext(_ctx, getState()); - enterRule(_localctx, 0, RULE_literal); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(474); - _la = _input.LA(1); - if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral))) != 0))) { - _errHandler.recoverInline(this); - } else { - consume(); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeContext extends ParserRuleContext { - public PrimitiveTypeContext primitiveType() { - return getRuleContext(PrimitiveTypeContext.class, 0); - } - - public ReferenceTypeContext referenceType() { - return getRuleContext(ReferenceTypeContext.class, 0); - } - - public TypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_type; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) return ((Java8Visitor<? extends Result>) visitor).visitType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeContext type() throws RecognitionException { - TypeContext _localctx = new TypeContext(_ctx, getState()); - enterRule(_localctx, 2, RULE_type); - try { - setState(478); - switch (getInterpreter().adaptivePredict(_input, 0, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(476); - primitiveType(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(477); - referenceType(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PrimitiveTypeContext extends ParserRuleContext { - public NumericTypeContext numericType() { - return getRuleContext(NumericTypeContext.class, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_primitiveType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPrimitiveType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PrimitiveTypeContext primitiveType() throws RecognitionException { - PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState()); - enterRule(_localctx, 4, RULE_primitiveType); - int _la; - try { - setState(494); - switch (getInterpreter().adaptivePredict(_input, 3, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(483); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(480); - annotation(); - } - } - setState(485); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(486); - numericType(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(490); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(487); - annotation(); - } - } - setState(492); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(493); - match(BOOLEAN); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class NumericTypeContext extends ParserRuleContext { - public IntegralTypeContext integralType() { - return getRuleContext(IntegralTypeContext.class, 0); - } - - public FloatingPointTypeContext floatingPointType() { - return getRuleContext(FloatingPointTypeContext.class, 0); - } - - public NumericTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_numericType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitNumericType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final NumericTypeContext numericType() throws RecognitionException { - NumericTypeContext _localctx = new NumericTypeContext(_ctx, getState()); - enterRule(_localctx, 6, RULE_numericType); - try { - setState(498); - switch (_input.LA(1)) { - case BYTE: - case CHAR: - case INT: - case LONG: - case SHORT: - enterOuterAlt(_localctx, 1); - { - setState(496); - integralType(); - } - break; - case DOUBLE: - case FLOAT: - enterOuterAlt(_localctx, 2); - { - setState(497); - floatingPointType(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class IntegralTypeContext extends ParserRuleContext { - public IntegralTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_integralType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitIntegralType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final IntegralTypeContext integralType() throws RecognitionException { - IntegralTypeContext _localctx = new IntegralTypeContext(_ctx, getState()); - enterRule(_localctx, 8, RULE_integralType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(500); - _la = _input.LA(1); - if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << CHAR) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0))) { - _errHandler.recoverInline(this); - } else { - consume(); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class FloatingPointTypeContext extends ParserRuleContext { - public FloatingPointTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_floatingPointType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitFloatingPointType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final FloatingPointTypeContext floatingPointType() throws RecognitionException { - FloatingPointTypeContext _localctx = new FloatingPointTypeContext(_ctx, getState()); - enterRule(_localctx, 10, RULE_floatingPointType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(502); - _la = _input.LA(1); - if (!(_la == DOUBLE || _la == FLOAT)) { - _errHandler.recoverInline(this); - } else { - consume(); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ReferenceTypeContext extends ParserRuleContext { - public ClassOrInterfaceTypeContext classOrInterfaceType() { - return getRuleContext(ClassOrInterfaceTypeContext.class, 0); - } - - public TypeVariableContext typeVariable() { - return getRuleContext(TypeVariableContext.class, 0); - } - - public ArrayTypeContext arrayType() { - return getRuleContext(ArrayTypeContext.class, 0); - } - - public ReferenceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_referenceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitReferenceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ReferenceTypeContext referenceType() throws RecognitionException { - ReferenceTypeContext _localctx = new ReferenceTypeContext(_ctx, getState()); - enterRule(_localctx, 12, RULE_referenceType); - try { - setState(507); - switch (getInterpreter().adaptivePredict(_input, 5, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(504); - classOrInterfaceType(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(505); - typeVariable(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(506); - arrayType(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassOrInterfaceTypeContext extends ParserRuleContext { - public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() { - return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class, 0); - } - - public InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() { - return getRuleContext(InterfaceType_lfno_classOrInterfaceTypeContext.class, 0); - } - - public List<? extends ClassType_lf_classOrInterfaceTypeContext> classType_lf_classOrInterfaceType() { - return getRuleContexts(ClassType_lf_classOrInterfaceTypeContext.class); - } - - public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType(int i) { - return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class, i); - } - - public List<? extends InterfaceType_lf_classOrInterfaceTypeContext> interfaceType_lf_classOrInterfaceType() { - return getRuleContexts(InterfaceType_lf_classOrInterfaceTypeContext.class); - } - - public InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType(int i) { - return getRuleContext(InterfaceType_lf_classOrInterfaceTypeContext.class, i); - } - - public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classOrInterfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException { - ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 14, RULE_classOrInterfaceType); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(511); - switch (getInterpreter().adaptivePredict(_input, 6, _ctx)) { - case 1: { - setState(509); - classType_lfno_classOrInterfaceType(); - } - break; - case 2: { - setState(510); - interfaceType_lfno_classOrInterfaceType(); - } - break; - } - setState(517); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 8, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - setState(515); - switch (getInterpreter().adaptivePredict(_input, 7, _ctx)) { - case 1: { - setState(513); - classType_lf_classOrInterfaceType(); - } - break; - case 2: { - setState(514); - interfaceType_lf_classOrInterfaceType(); - } - break; - } - } - } - setState(519); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 8, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassTypeContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public ClassOrInterfaceTypeContext classOrInterfaceType() { - return getRuleContext(ClassOrInterfaceTypeContext.class, 0); - } - - public ClassTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassTypeContext classType() throws RecognitionException { - ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState()); - enterRule(_localctx, 16, RULE_classType); - int _la; - try { - setState(542); - switch (getInterpreter().adaptivePredict(_input, 13, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(523); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(520); - annotation(); - } - } - setState(525); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(526); - match(Identifier); - setState(528); - _la = _input.LA(1); - if (_la == LT) { - { - setState(527); - typeArguments(); - } - } - - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(530); - classOrInterfaceType(); - setState(531); - match(DOT); - setState(535); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(532); - annotation(); - } - } - setState(537); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(538); - match(Identifier); - setState(540); - _la = _input.LA(1); - if (_la == LT) { - { - setState(539); - typeArguments(); - } - } - - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassType_lf_classOrInterfaceTypeContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public ClassType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classType_lf_classOrInterfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassType_lf_classOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() throws RecognitionException { - ClassType_lf_classOrInterfaceTypeContext _localctx = new ClassType_lf_classOrInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 18, RULE_classType_lf_classOrInterfaceType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(544); - match(DOT); - setState(548); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(545); - annotation(); - } - } - setState(550); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(551); - match(Identifier); - setState(553); - switch (getInterpreter().adaptivePredict(_input, 15, _ctx)) { - case 1: { - setState(552); - typeArguments(); - } - break; - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassType_lfno_classOrInterfaceTypeContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public ClassType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classType_lfno_classOrInterfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassType_lfno_classOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() throws RecognitionException { - ClassType_lfno_classOrInterfaceTypeContext _localctx = new ClassType_lfno_classOrInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 20, RULE_classType_lfno_classOrInterfaceType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(558); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(555); - annotation(); - } - } - setState(560); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(561); - match(Identifier); - setState(563); - switch (getInterpreter().adaptivePredict(_input, 17, _ctx)) { - case 1: { - setState(562); - typeArguments(); - } - break; - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceTypeContext extends ParserRuleContext { - public ClassTypeContext classType() { - return getRuleContext(ClassTypeContext.class, 0); - } - - public InterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InterfaceTypeContext interfaceType() throws RecognitionException { - InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 22, RULE_interfaceType); - try { - enterOuterAlt(_localctx, 1); - { - setState(565); - classType(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceType_lf_classOrInterfaceTypeContext extends ParserRuleContext { - public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() { - return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class, 0); - } - - public InterfaceType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceType_lf_classOrInterfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInterfaceType_lf_classOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType() throws RecognitionException { - InterfaceType_lf_classOrInterfaceTypeContext _localctx = new InterfaceType_lf_classOrInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 24, RULE_interfaceType_lf_classOrInterfaceType); - try { - enterOuterAlt(_localctx, 1); - { - setState(567); - classType_lf_classOrInterfaceType(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceType_lfno_classOrInterfaceTypeContext extends ParserRuleContext { - public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() { - return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class, 0); - } - - public InterfaceType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceType_lfno_classOrInterfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInterfaceType_lfno_classOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() throws RecognitionException { - InterfaceType_lfno_classOrInterfaceTypeContext _localctx = new InterfaceType_lfno_classOrInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 26, RULE_interfaceType_lfno_classOrInterfaceType); - try { - enterOuterAlt(_localctx, 1); - { - setState(569); - classType_lfno_classOrInterfaceType(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeVariableContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public TypeVariableContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeVariable; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeVariable(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeVariableContext typeVariable() throws RecognitionException { - TypeVariableContext _localctx = new TypeVariableContext(_ctx, getState()); - enterRule(_localctx, 28, RULE_typeVariable); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(574); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(571); - annotation(); - } - } - setState(576); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(577); - match(Identifier); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ArrayTypeContext extends ParserRuleContext { - public PrimitiveTypeContext primitiveType() { - return getRuleContext(PrimitiveTypeContext.class, 0); - } - - public DimsContext dims() { - return getRuleContext(DimsContext.class, 0); - } - - public ClassOrInterfaceTypeContext classOrInterfaceType() { - return getRuleContext(ClassOrInterfaceTypeContext.class, 0); - } - - public TypeVariableContext typeVariable() { - return getRuleContext(TypeVariableContext.class, 0); - } - - public ArrayTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_arrayType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitArrayType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ArrayTypeContext arrayType() throws RecognitionException { - ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState()); - enterRule(_localctx, 30, RULE_arrayType); - try { - setState(588); - switch (getInterpreter().adaptivePredict(_input, 19, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(579); - primitiveType(); - setState(580); - dims(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(582); - classOrInterfaceType(); - setState(583); - dims(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(585); - typeVariable(); - setState(586); - dims(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class DimsContext extends ParserRuleContext { - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public DimsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_dims; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) return ((Java8Visitor<? extends Result>) visitor).visitDims(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final DimsContext dims() throws RecognitionException { - DimsContext _localctx = new DimsContext(_ctx, getState()); - enterRule(_localctx, 32, RULE_dims); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(593); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(590); - annotation(); - } - } - setState(595); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(596); - match(LBRACK); - setState(597); - match(RBRACK); - setState(608); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 22, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(601); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(598); - annotation(); - } - } - setState(603); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(604); - match(LBRACK); - setState(605); - match(RBRACK); - } - } - } - setState(610); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 22, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeParameterContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public List<? extends TypeParameterModifierContext> typeParameterModifier() { - return getRuleContexts(TypeParameterModifierContext.class); - } - - public TypeParameterModifierContext typeParameterModifier(int i) { - return getRuleContext(TypeParameterModifierContext.class, i); - } - - public TypeBoundContext typeBound() { - return getRuleContext(TypeBoundContext.class, 0); - } - - public TypeParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeParameter; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeParameter(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeParameterContext typeParameter() throws RecognitionException { - TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); - enterRule(_localctx, 34, RULE_typeParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(614); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(611); - typeParameterModifier(); - } - } - setState(616); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(617); - match(Identifier); - setState(619); - _la = _input.LA(1); - if (_la == EXTENDS) { - { - setState(618); - typeBound(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeParameterModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeParameterModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeParameterModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException { - TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState()); - enterRule(_localctx, 36, RULE_typeParameterModifier); - try { - enterOuterAlt(_localctx, 1); - { - setState(621); - annotation(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeBoundContext extends ParserRuleContext { - public TypeVariableContext typeVariable() { - return getRuleContext(TypeVariableContext.class, 0); - } - - public ClassOrInterfaceTypeContext classOrInterfaceType() { - return getRuleContext(ClassOrInterfaceTypeContext.class, 0); - } - - public List<? extends AdditionalBoundContext> additionalBound() { - return getRuleContexts(AdditionalBoundContext.class); - } - - public AdditionalBoundContext additionalBound(int i) { - return getRuleContext(AdditionalBoundContext.class, i); - } - - public TypeBoundContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeBound; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeBound(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeBoundContext typeBound() throws RecognitionException { - TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState()); - enterRule(_localctx, 38, RULE_typeBound); - int _la; - try { - setState(633); - switch (getInterpreter().adaptivePredict(_input, 26, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(623); - match(EXTENDS); - setState(624); - typeVariable(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(625); - match(EXTENDS); - setState(626); - classOrInterfaceType(); - setState(630); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == BITAND) { - { - { - setState(627); - additionalBound(); - } - } - setState(632); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AdditionalBoundContext extends ParserRuleContext { - public InterfaceTypeContext interfaceType() { - return getRuleContext(InterfaceTypeContext.class, 0); - } - - public AdditionalBoundContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_additionalBound; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAdditionalBound(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AdditionalBoundContext additionalBound() throws RecognitionException { - AdditionalBoundContext _localctx = new AdditionalBoundContext(_ctx, getState()); - enterRule(_localctx, 40, RULE_additionalBound); - try { - enterOuterAlt(_localctx, 1); - { - setState(635); - match(BITAND); - setState(636); - interfaceType(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeArgumentsContext extends ParserRuleContext { - public TypeArgumentListContext typeArgumentList() { - return getRuleContext(TypeArgumentListContext.class, 0); - } - - public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeArguments; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeArguments(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeArgumentsContext typeArguments() throws RecognitionException { - TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); - enterRule(_localctx, 42, RULE_typeArguments); - try { - enterOuterAlt(_localctx, 1); - { - setState(638); - match(LT); - setState(639); - typeArgumentList(); - setState(640); - match(GT); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeArgumentListContext extends ParserRuleContext { - public List<? extends TypeArgumentContext> typeArgument() { - return getRuleContexts(TypeArgumentContext.class); - } - - public TypeArgumentContext typeArgument(int i) { - return getRuleContext(TypeArgumentContext.class, i); - } - - public TypeArgumentListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeArgumentList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeArgumentList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeArgumentListContext typeArgumentList() throws RecognitionException { - TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState()); - enterRule(_localctx, 44, RULE_typeArgumentList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(642); - typeArgument(); - setState(647); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(643); - match(COMMA); - setState(644); - typeArgument(); - } - } - setState(649); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeArgumentContext extends ParserRuleContext { - public ReferenceTypeContext referenceType() { - return getRuleContext(ReferenceTypeContext.class, 0); - } - - public WildcardContext wildcard() { - return getRuleContext(WildcardContext.class, 0); - } - - public TypeArgumentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeArgument; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeArgument(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeArgumentContext typeArgument() throws RecognitionException { - TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState()); - enterRule(_localctx, 46, RULE_typeArgument); - try { - setState(652); - switch (getInterpreter().adaptivePredict(_input, 28, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(650); - referenceType(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(651); - wildcard(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class WildcardContext extends ParserRuleContext { - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public WildcardBoundsContext wildcardBounds() { - return getRuleContext(WildcardBoundsContext.class, 0); - } - - public WildcardContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_wildcard; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitWildcard(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final WildcardContext wildcard() throws RecognitionException { - WildcardContext _localctx = new WildcardContext(_ctx, getState()); - enterRule(_localctx, 48, RULE_wildcard); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(657); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(654); - annotation(); - } - } - setState(659); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(660); - match(QUESTION); - setState(662); - _la = _input.LA(1); - if (_la == EXTENDS || _la == SUPER) { - { - setState(661); - wildcardBounds(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class WildcardBoundsContext extends ParserRuleContext { - public ReferenceTypeContext referenceType() { - return getRuleContext(ReferenceTypeContext.class, 0); - } - - public WildcardBoundsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_wildcardBounds; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitWildcardBounds(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final WildcardBoundsContext wildcardBounds() throws RecognitionException { - WildcardBoundsContext _localctx = new WildcardBoundsContext(_ctx, getState()); - enterRule(_localctx, 50, RULE_wildcardBounds); - try { - setState(668); - switch (_input.LA(1)) { - case EXTENDS: - enterOuterAlt(_localctx, 1); - { - setState(664); - match(EXTENDS); - setState(665); - referenceType(); - } - break; - case SUPER: - enterOuterAlt(_localctx, 2); - { - setState(666); - match(SUPER); - setState(667); - referenceType(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PackageNameContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public PackageNameContext packageName() { - return getRuleContext(PackageNameContext.class, 0); - } - - public PackageNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_packageName; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPackageName(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PackageNameContext packageName() throws RecognitionException { - return packageName(0); - } - - private PackageNameContext packageName(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - PackageNameContext _localctx = new PackageNameContext(_ctx, _parentState); - PackageNameContext _prevctx = _localctx; - int _startState = 52; - enterRecursionRule(_localctx, 52, RULE_packageName, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(671); - match(Identifier); - } - _ctx.stop = _input.LT(-1); - setState(678); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 32, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - { - _localctx = new PackageNameContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_packageName); - setState(673); - if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(674); - match(DOT); - setState(675); - match(Identifier); - } - } - } - setState(680); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 32, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class TypeNameContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public PackageOrTypeNameContext packageOrTypeName() { - return getRuleContext(PackageOrTypeNameContext.class, 0); - } - - public TypeNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeName; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeName(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeNameContext typeName() throws RecognitionException { - TypeNameContext _localctx = new TypeNameContext(_ctx, getState()); - enterRule(_localctx, 54, RULE_typeName); - try { - setState(686); - switch (getInterpreter().adaptivePredict(_input, 33, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(681); - match(Identifier); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(682); - packageOrTypeName(0); - setState(683); - match(DOT); - setState(684); - match(Identifier); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PackageOrTypeNameContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public PackageOrTypeNameContext packageOrTypeName() { - return getRuleContext(PackageOrTypeNameContext.class, 0); - } - - public PackageOrTypeNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_packageOrTypeName; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPackageOrTypeName(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PackageOrTypeNameContext packageOrTypeName() throws RecognitionException { - return packageOrTypeName(0); - } - - private PackageOrTypeNameContext packageOrTypeName(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - PackageOrTypeNameContext _localctx = new PackageOrTypeNameContext(_ctx, _parentState); - PackageOrTypeNameContext _prevctx = _localctx; - int _startState = 56; - enterRecursionRule(_localctx, 56, RULE_packageOrTypeName, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(689); - match(Identifier); - } - _ctx.stop = _input.LT(-1); - setState(696); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 34, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - { - _localctx = new PackageOrTypeNameContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_packageOrTypeName); - setState(691); - if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(692); - match(DOT); - setState(693); - match(Identifier); - } - } - } - setState(698); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 34, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class ExpressionNameContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public AmbiguousNameContext ambiguousName() { - return getRuleContext(AmbiguousNameContext.class, 0); - } - - public ExpressionNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_expressionName; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitExpressionName(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ExpressionNameContext expressionName() throws RecognitionException { - ExpressionNameContext _localctx = new ExpressionNameContext(_ctx, getState()); - enterRule(_localctx, 58, RULE_expressionName); - try { - setState(704); - switch (getInterpreter().adaptivePredict(_input, 35, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(699); - match(Identifier); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(700); - ambiguousName(0); - setState(701); - match(DOT); - setState(702); - match(Identifier); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodNameContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public MethodNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodName; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodName(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodNameContext methodName() throws RecognitionException { - MethodNameContext _localctx = new MethodNameContext(_ctx, getState()); - enterRule(_localctx, 60, RULE_methodName); - try { - enterOuterAlt(_localctx, 1); - { - setState(706); - match(Identifier); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AmbiguousNameContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public AmbiguousNameContext ambiguousName() { - return getRuleContext(AmbiguousNameContext.class, 0); - } - - public AmbiguousNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_ambiguousName; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAmbiguousName(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AmbiguousNameContext ambiguousName() throws RecognitionException { - return ambiguousName(0); - } - - private AmbiguousNameContext ambiguousName(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - AmbiguousNameContext _localctx = new AmbiguousNameContext(_ctx, _parentState); - AmbiguousNameContext _prevctx = _localctx; - int _startState = 62; - enterRecursionRule(_localctx, 62, RULE_ambiguousName, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(709); - match(Identifier); - } - _ctx.stop = _input.LT(-1); - setState(716); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 36, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - { - _localctx = new AmbiguousNameContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_ambiguousName); - setState(711); - if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(712); - match(DOT); - setState(713); - match(Identifier); - } - } - } - setState(718); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 36, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class CompilationUnitContext extends ParserRuleContext { - public TerminalNode EOF() { - return getToken(Java8Parser.EOF, 0); - } - - public PackageDeclarationContext packageDeclaration() { - return getRuleContext(PackageDeclarationContext.class, 0); - } - - public List<? extends ImportDeclarationContext> importDeclaration() { - return getRuleContexts(ImportDeclarationContext.class); - } - - public ImportDeclarationContext importDeclaration(int i) { - return getRuleContext(ImportDeclarationContext.class, i); - } - - public List<? extends TypeDeclarationContext> typeDeclaration() { - return getRuleContexts(TypeDeclarationContext.class); - } - - public TypeDeclarationContext typeDeclaration(int i) { - return getRuleContext(TypeDeclarationContext.class, i); - } - - public CompilationUnitContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_compilationUnit; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitCompilationUnit(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final CompilationUnitContext compilationUnit() throws RecognitionException { - CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState()); - enterRule(_localctx, 64, RULE_compilationUnit); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(720); - switch (getInterpreter().adaptivePredict(_input, 37, _ctx)) { - case 1: { - setState(719); - packageDeclaration(); - } - break; - } - setState(725); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == IMPORT) { - { - { - setState(722); - importDeclaration(); - } - } - setState(727); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(731); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SEMI))) != 0) || _la == AT) { - { - { - setState(728); - typeDeclaration(); - } - } - setState(733); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(734); - match(EOF); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PackageDeclarationContext extends ParserRuleContext { - public List<? extends TerminalNode> Identifier() { - return getTokens(Java8Parser.Identifier); - } - - public TerminalNode Identifier(int i) { - return getToken(Java8Parser.Identifier, i); - } - - public List<? extends PackageModifierContext> packageModifier() { - return getRuleContexts(PackageModifierContext.class); - } - - public PackageModifierContext packageModifier(int i) { - return getRuleContext(PackageModifierContext.class, i); - } - - public PackageDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_packageDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPackageDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PackageDeclarationContext packageDeclaration() throws RecognitionException { - PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState()); - enterRule(_localctx, 66, RULE_packageDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(739); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(736); - packageModifier(); - } - } - setState(741); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(742); - match(PACKAGE); - setState(743); - match(Identifier); - setState(748); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == DOT) { - { - { - setState(744); - match(DOT); - setState(745); - match(Identifier); - } - } - setState(750); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(751); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PackageModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public PackageModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_packageModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPackageModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PackageModifierContext packageModifier() throws RecognitionException { - PackageModifierContext _localctx = new PackageModifierContext(_ctx, getState()); - enterRule(_localctx, 68, RULE_packageModifier); - try { - enterOuterAlt(_localctx, 1); - { - setState(753); - annotation(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ImportDeclarationContext extends ParserRuleContext { - public SingleTypeImportDeclarationContext singleTypeImportDeclaration() { - return getRuleContext(SingleTypeImportDeclarationContext.class, 0); - } - - public TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() { - return getRuleContext(TypeImportOnDemandDeclarationContext.class, 0); - } - - public SingleStaticImportDeclarationContext singleStaticImportDeclaration() { - return getRuleContext(SingleStaticImportDeclarationContext.class, 0); - } - - public StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() { - return getRuleContext(StaticImportOnDemandDeclarationContext.class, 0); - } - - public ImportDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_importDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitImportDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ImportDeclarationContext importDeclaration() throws RecognitionException { - ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState()); - enterRule(_localctx, 70, RULE_importDeclaration); - try { - setState(759); - switch (getInterpreter().adaptivePredict(_input, 42, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(755); - singleTypeImportDeclaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(756); - typeImportOnDemandDeclaration(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(757); - singleStaticImportDeclaration(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(758); - staticImportOnDemandDeclaration(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SingleTypeImportDeclarationContext extends ParserRuleContext { - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public SingleTypeImportDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_singleTypeImportDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSingleTypeImportDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SingleTypeImportDeclarationContext singleTypeImportDeclaration() throws RecognitionException { - SingleTypeImportDeclarationContext _localctx = new SingleTypeImportDeclarationContext(_ctx, getState()); - enterRule(_localctx, 72, RULE_singleTypeImportDeclaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(761); - match(IMPORT); - setState(762); - typeName(); - setState(763); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeImportOnDemandDeclarationContext extends ParserRuleContext { - public PackageOrTypeNameContext packageOrTypeName() { - return getRuleContext(PackageOrTypeNameContext.class, 0); - } - - public TypeImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeImportOnDemandDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeImportOnDemandDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() throws RecognitionException { - TypeImportOnDemandDeclarationContext _localctx = new TypeImportOnDemandDeclarationContext(_ctx, getState()); - enterRule(_localctx, 74, RULE_typeImportOnDemandDeclaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(765); - match(IMPORT); - setState(766); - packageOrTypeName(0); - setState(767); - match(DOT); - setState(768); - match(MUL); - setState(769); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SingleStaticImportDeclarationContext extends ParserRuleContext { - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public SingleStaticImportDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_singleStaticImportDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSingleStaticImportDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SingleStaticImportDeclarationContext singleStaticImportDeclaration() throws RecognitionException { - SingleStaticImportDeclarationContext _localctx = new SingleStaticImportDeclarationContext(_ctx, getState()); - enterRule(_localctx, 76, RULE_singleStaticImportDeclaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(771); - match(IMPORT); - setState(772); - match(STATIC); - setState(773); - typeName(); - setState(774); - match(DOT); - setState(775); - match(Identifier); - setState(776); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class StaticImportOnDemandDeclarationContext extends ParserRuleContext { - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public StaticImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_staticImportOnDemandDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitStaticImportOnDemandDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() throws RecognitionException { - StaticImportOnDemandDeclarationContext _localctx = new StaticImportOnDemandDeclarationContext(_ctx, getState()); - enterRule(_localctx, 78, RULE_staticImportOnDemandDeclaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(778); - match(IMPORT); - setState(779); - match(STATIC); - setState(780); - typeName(); - setState(781); - match(DOT); - setState(782); - match(MUL); - setState(783); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeDeclarationContext extends ParserRuleContext { - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class, 0); - } - - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class, 0); - } - - public TypeDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeDeclarationContext typeDeclaration() throws RecognitionException { - TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState()); - enterRule(_localctx, 80, RULE_typeDeclaration); - try { - setState(788); - switch (getInterpreter().adaptivePredict(_input, 43, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(785); - classDeclaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(786); - interfaceDeclaration(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(787); - match(SEMI); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassDeclarationContext extends ParserRuleContext { - public NormalClassDeclarationContext normalClassDeclaration() { - return getRuleContext(NormalClassDeclarationContext.class, 0); - } - - public EnumDeclarationContext enumDeclaration() { - return getRuleContext(EnumDeclarationContext.class, 0); - } - - public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassDeclarationContext classDeclaration() throws RecognitionException { - ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); - enterRule(_localctx, 82, RULE_classDeclaration); - try { - setState(792); - switch (getInterpreter().adaptivePredict(_input, 44, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(790); - normalClassDeclaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(791); - enumDeclaration(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class NormalClassDeclarationContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class, 0); - } - - public List<? extends ClassModifierContext> classModifier() { - return getRuleContexts(ClassModifierContext.class); - } - - public ClassModifierContext classModifier(int i) { - return getRuleContext(ClassModifierContext.class, i); - } - - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class, 0); - } - - public SuperclassContext superclass() { - return getRuleContext(SuperclassContext.class, 0); - } - - public SuperinterfacesContext superinterfaces() { - return getRuleContext(SuperinterfacesContext.class, 0); - } - - public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_normalClassDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitNormalClassDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final NormalClassDeclarationContext normalClassDeclaration() throws RecognitionException { - NormalClassDeclarationContext _localctx = new NormalClassDeclarationContext(_ctx, getState()); - enterRule(_localctx, 84, RULE_normalClassDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(797); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la == AT) { - { - { - setState(794); - classModifier(); - } - } - setState(799); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(800); - match(CLASS); - setState(801); - match(Identifier); - setState(803); - _la = _input.LA(1); - if (_la == LT) { - { - setState(802); - typeParameters(); - } - } - - setState(806); - _la = _input.LA(1); - if (_la == EXTENDS) { - { - setState(805); - superclass(); - } - } - - setState(809); - _la = _input.LA(1); - if (_la == IMPLEMENTS) { - { - setState(808); - superinterfaces(); - } - } - - setState(811); - classBody(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public ClassModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassModifierContext classModifier() throws RecognitionException { - ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState()); - enterRule(_localctx, 86, RULE_classModifier); - try { - setState(821); - switch (_input.LA(1)) { - case AT: - enterOuterAlt(_localctx, 1); - { - setState(813); - annotation(); - } - break; - case PUBLIC: - enterOuterAlt(_localctx, 2); - { - setState(814); - match(PUBLIC); - } - break; - case PROTECTED: - enterOuterAlt(_localctx, 3); - { - setState(815); - match(PROTECTED); - } - break; - case PRIVATE: - enterOuterAlt(_localctx, 4); - { - setState(816); - match(PRIVATE); - } - break; - case ABSTRACT: - enterOuterAlt(_localctx, 5); - { - setState(817); - match(ABSTRACT); - } - break; - case STATIC: - enterOuterAlt(_localctx, 6); - { - setState(818); - match(STATIC); - } - break; - case FINAL: - enterOuterAlt(_localctx, 7); - { - setState(819); - match(FINAL); - } - break; - case STRICTFP: - enterOuterAlt(_localctx, 8); - { - setState(820); - match(STRICTFP); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeParametersContext extends ParserRuleContext { - public TypeParameterListContext typeParameterList() { - return getRuleContext(TypeParameterListContext.class, 0); - } - - public TypeParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeParameters; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeParameters(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeParametersContext typeParameters() throws RecognitionException { - TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); - enterRule(_localctx, 88, RULE_typeParameters); - try { - enterOuterAlt(_localctx, 1); - { - setState(823); - match(LT); - setState(824); - typeParameterList(); - setState(825); - match(GT); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeParameterListContext extends ParserRuleContext { - public List<? extends TypeParameterContext> typeParameter() { - return getRuleContexts(TypeParameterContext.class); - } - - public TypeParameterContext typeParameter(int i) { - return getRuleContext(TypeParameterContext.class, i); - } - - public TypeParameterListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeParameterList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeParameterList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeParameterListContext typeParameterList() throws RecognitionException { - TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState()); - enterRule(_localctx, 90, RULE_typeParameterList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(827); - typeParameter(); - setState(832); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(828); - match(COMMA); - setState(829); - typeParameter(); - } - } - setState(834); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SuperclassContext extends ParserRuleContext { - public ClassTypeContext classType() { - return getRuleContext(ClassTypeContext.class, 0); - } - - public SuperclassContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_superclass; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSuperclass(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SuperclassContext superclass() throws RecognitionException { - SuperclassContext _localctx = new SuperclassContext(_ctx, getState()); - enterRule(_localctx, 92, RULE_superclass); - try { - enterOuterAlt(_localctx, 1); - { - setState(835); - match(EXTENDS); - setState(836); - classType(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SuperinterfacesContext extends ParserRuleContext { - public InterfaceTypeListContext interfaceTypeList() { - return getRuleContext(InterfaceTypeListContext.class, 0); - } - - public SuperinterfacesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_superinterfaces; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSuperinterfaces(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SuperinterfacesContext superinterfaces() throws RecognitionException { - SuperinterfacesContext _localctx = new SuperinterfacesContext(_ctx, getState()); - enterRule(_localctx, 94, RULE_superinterfaces); - try { - enterOuterAlt(_localctx, 1); - { - setState(838); - match(IMPLEMENTS); - setState(839); - interfaceTypeList(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceTypeListContext extends ParserRuleContext { - public List<? extends InterfaceTypeContext> interfaceType() { - return getRuleContexts(InterfaceTypeContext.class); - } - - public InterfaceTypeContext interfaceType(int i) { - return getRuleContext(InterfaceTypeContext.class, i); - } - - public InterfaceTypeListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceTypeList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInterfaceTypeList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InterfaceTypeListContext interfaceTypeList() throws RecognitionException { - InterfaceTypeListContext _localctx = new InterfaceTypeListContext(_ctx, getState()); - enterRule(_localctx, 96, RULE_interfaceTypeList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(841); - interfaceType(); - setState(846); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(842); - match(COMMA); - setState(843); - interfaceType(); - } - } - setState(848); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassBodyContext extends ParserRuleContext { - public List<? extends ClassBodyDeclarationContext> classBodyDeclaration() { - return getRuleContexts(ClassBodyDeclarationContext.class); - } - - public ClassBodyDeclarationContext classBodyDeclaration(int i) { - return getRuleContext(ClassBodyDeclarationContext.class, i); - } - - public ClassBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classBody; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassBody(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassBodyContext classBody() throws RecognitionException { - ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState()); - enterRule(_localctx, 98, RULE_classBody); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(849); - match(LBRACE); - setState(853); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << LBRACE) | (1L << SEMI))) [...] - { - { - setState(850); - classBodyDeclaration(); - } - } - setState(855); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(856); - match(RBRACE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassBodyDeclarationContext extends ParserRuleContext { - public ClassMemberDeclarationContext classMemberDeclaration() { - return getRuleContext(ClassMemberDeclarationContext.class, 0); - } - - public InstanceInitializerContext instanceInitializer() { - return getRuleContext(InstanceInitializerContext.class, 0); - } - - public StaticInitializerContext staticInitializer() { - return getRuleContext(StaticInitializerContext.class, 0); - } - - public ConstructorDeclarationContext constructorDeclaration() { - return getRuleContext(ConstructorDeclarationContext.class, 0); - } - - public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classBodyDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassBodyDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException { - ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState()); - enterRule(_localctx, 100, RULE_classBodyDeclaration); - try { - setState(862); - switch (getInterpreter().adaptivePredict(_input, 53, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(858); - classMemberDeclaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(859); - instanceInitializer(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(860); - staticInitializer(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(861); - constructorDeclaration(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassMemberDeclarationContext extends ParserRuleContext { - public FieldDeclarationContext fieldDeclaration() { - return getRuleContext(FieldDeclarationContext.class, 0); - } - - public MethodDeclarationContext methodDeclaration() { - return getRuleContext(MethodDeclarationContext.class, 0); - } - - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class, 0); - } - - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class, 0); - } - - public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classMemberDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassMemberDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException { - ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState()); - enterRule(_localctx, 102, RULE_classMemberDeclaration); - try { - setState(869); - switch (getInterpreter().adaptivePredict(_input, 54, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(864); - fieldDeclaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(865); - methodDeclaration(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(866); - classDeclaration(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(867); - interfaceDeclaration(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(868); - match(SEMI); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class FieldDeclarationContext extends ParserRuleContext { - public UnannTypeContext unannType() { - return getRuleContext(UnannTypeContext.class, 0); - } - - public VariableDeclaratorListContext variableDeclaratorList() { - return getRuleContext(VariableDeclaratorListContext.class, 0); - } - - public List<? extends FieldModifierContext> fieldModifier() { - return getRuleContexts(FieldModifierContext.class); - } - - public FieldModifierContext fieldModifier(int i) { - return getRuleContext(FieldModifierContext.class, i); - } - - public FieldDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_fieldDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitFieldDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final FieldDeclarationContext fieldDeclaration() throws RecognitionException { - FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState()); - enterRule(_localctx, 104, RULE_fieldDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(874); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << TRANSIENT) | (1L << VOLATILE))) != 0) || _la == AT) { - { - { - setState(871); - fieldModifier(); - } - } - setState(876); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(877); - unannType(); - setState(878); - variableDeclaratorList(); - setState(879); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class FieldModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public FieldModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_fieldModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitFieldModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final FieldModifierContext fieldModifier() throws RecognitionException { - FieldModifierContext _localctx = new FieldModifierContext(_ctx, getState()); - enterRule(_localctx, 106, RULE_fieldModifier); - try { - setState(889); - switch (_input.LA(1)) { - case AT: - enterOuterAlt(_localctx, 1); - { - setState(881); - annotation(); - } - break; - case PUBLIC: - enterOuterAlt(_localctx, 2); - { - setState(882); - match(PUBLIC); - } - break; - case PROTECTED: - enterOuterAlt(_localctx, 3); - { - setState(883); - match(PROTECTED); - } - break; - case PRIVATE: - enterOuterAlt(_localctx, 4); - { - setState(884); - match(PRIVATE); - } - break; - case STATIC: - enterOuterAlt(_localctx, 5); - { - setState(885); - match(STATIC); - } - break; - case FINAL: - enterOuterAlt(_localctx, 6); - { - setState(886); - match(FINAL); - } - break; - case TRANSIENT: - enterOuterAlt(_localctx, 7); - { - setState(887); - match(TRANSIENT); - } - break; - case VOLATILE: - enterOuterAlt(_localctx, 8); - { - setState(888); - match(VOLATILE); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class VariableDeclaratorListContext extends ParserRuleContext { - public List<? extends VariableDeclaratorContext> variableDeclarator() { - return getRuleContexts(VariableDeclaratorContext.class); - } - - public VariableDeclaratorContext variableDeclarator(int i) { - return getRuleContext(VariableDeclaratorContext.class, i); - } - - public VariableDeclaratorListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_variableDeclaratorList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitVariableDeclaratorList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final VariableDeclaratorListContext variableDeclaratorList() throws RecognitionException { - VariableDeclaratorListContext _localctx = new VariableDeclaratorListContext(_ctx, getState()); - enterRule(_localctx, 108, RULE_variableDeclaratorList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(891); - variableDeclarator(); - setState(896); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(892); - match(COMMA); - setState(893); - variableDeclarator(); - } - } - setState(898); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class VariableDeclaratorContext extends ParserRuleContext { - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public VariableInitializerContext variableInitializer() { - return getRuleContext(VariableInitializerContext.class, 0); - } - - public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_variableDeclarator; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitVariableDeclarator(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final VariableDeclaratorContext variableDeclarator() throws RecognitionException { - VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState()); - enterRule(_localctx, 110, RULE_variableDeclarator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(899); - variableDeclaratorId(); - setState(902); - _la = _input.LA(1); - if (_la == ASSIGN) { - { - setState(900); - match(ASSIGN); - setState(901); - variableInitializer(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class VariableDeclaratorIdContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public DimsContext dims() { - return getRuleContext(DimsContext.class, 0); - } - - public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_variableDeclaratorId; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitVariableDeclaratorId(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException { - VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState()); - enterRule(_localctx, 112, RULE_variableDeclaratorId); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(904); - match(Identifier); - setState(906); - _la = _input.LA(1); - if (_la == LBRACK || _la == AT) { - { - setState(905); - dims(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class VariableInitializerContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ArrayInitializerContext arrayInitializer() { - return getRuleContext(ArrayInitializerContext.class, 0); - } - - public VariableInitializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_variableInitializer; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitVariableInitializer(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final VariableInitializerContext variableInitializer() throws RecognitionException { - VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState()); - enterRule(_localctx, 114, RULE_variableInitializer); - try { - setState(910); - switch (_input.LA(1)) { - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case NEW: - case SHORT: - case SUPER: - case THIS: - case VOID: - case IntegerLiteral: - case FloatingPointLiteral: - case BooleanLiteral: - case CharacterLiteral: - case StringLiteral: - case NullLiteral: - case LPAREN: - case BANG: - case TILDE: - case INC: - case DEC: - case ADD: - case SUB: - case Identifier: - case AT: - enterOuterAlt(_localctx, 1); - { - setState(908); - expression(); - } - break; - case LBRACE: - enterOuterAlt(_localctx, 2); - { - setState(909); - arrayInitializer(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannTypeContext extends ParserRuleContext { - public UnannPrimitiveTypeContext unannPrimitiveType() { - return getRuleContext(UnannPrimitiveTypeContext.class, 0); - } - - public UnannReferenceTypeContext unannReferenceType() { - return getRuleContext(UnannReferenceTypeContext.class, 0); - } - - public UnannTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannTypeContext unannType() throws RecognitionException { - UnannTypeContext _localctx = new UnannTypeContext(_ctx, getState()); - enterRule(_localctx, 116, RULE_unannType); - try { - setState(914); - switch (getInterpreter().adaptivePredict(_input, 61, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(912); - unannPrimitiveType(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(913); - unannReferenceType(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannPrimitiveTypeContext extends ParserRuleContext { - public NumericTypeContext numericType() { - return getRuleContext(NumericTypeContext.class, 0); - } - - public UnannPrimitiveTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannPrimitiveType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannPrimitiveType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannPrimitiveTypeContext unannPrimitiveType() throws RecognitionException { - UnannPrimitiveTypeContext _localctx = new UnannPrimitiveTypeContext(_ctx, getState()); - enterRule(_localctx, 118, RULE_unannPrimitiveType); - try { - setState(918); - switch (_input.LA(1)) { - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - enterOuterAlt(_localctx, 1); - { - setState(916); - numericType(); - } - break; - case BOOLEAN: - enterOuterAlt(_localctx, 2); - { - setState(917); - match(BOOLEAN); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannReferenceTypeContext extends ParserRuleContext { - public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { - return getRuleContext(UnannClassOrInterfaceTypeContext.class, 0); - } - - public UnannTypeVariableContext unannTypeVariable() { - return getRuleContext(UnannTypeVariableContext.class, 0); - } - - public UnannArrayTypeContext unannArrayType() { - return getRuleContext(UnannArrayTypeContext.class, 0); - } - - public UnannReferenceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannReferenceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannReferenceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannReferenceTypeContext unannReferenceType() throws RecognitionException { - UnannReferenceTypeContext _localctx = new UnannReferenceTypeContext(_ctx, getState()); - enterRule(_localctx, 120, RULE_unannReferenceType); - try { - setState(923); - switch (getInterpreter().adaptivePredict(_input, 63, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(920); - unannClassOrInterfaceType(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(921); - unannTypeVariable(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(922); - unannArrayType(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannClassOrInterfaceTypeContext extends ParserRuleContext { - public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() { - return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class, 0); - } - - public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() { - return getRuleContext(UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext.class, 0); - } - - public List<? extends UnannClassType_lf_unannClassOrInterfaceTypeContext> unannClassType_lf_unannClassOrInterfaceType() { - return getRuleContexts(UnannClassType_lf_unannClassOrInterfaceTypeContext.class); - } - - public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType(int i) { - return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class, i); - } - - public List<? extends UnannInterfaceType_lf_unannClassOrInterfaceTypeContext> unannInterfaceType_lf_unannClassOrInterfaceType() { - return getRuleContexts(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class); - } - - public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType(int i) { - return getRuleContext(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class, i); - } - - public UnannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannClassOrInterfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannClassOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() throws RecognitionException { - UnannClassOrInterfaceTypeContext _localctx = new UnannClassOrInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 122, RULE_unannClassOrInterfaceType); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(927); - switch (getInterpreter().adaptivePredict(_input, 64, _ctx)) { - case 1: { - setState(925); - unannClassType_lfno_unannClassOrInterfaceType(); - } - break; - case 2: { - setState(926); - unannInterfaceType_lfno_unannClassOrInterfaceType(); - } - break; - } - setState(933); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 66, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - setState(931); - switch (getInterpreter().adaptivePredict(_input, 65, _ctx)) { - case 1: { - setState(929); - unannClassType_lf_unannClassOrInterfaceType(); - } - break; - case 2: { - setState(930); - unannInterfaceType_lf_unannClassOrInterfaceType(); - } - break; - } - } - } - setState(935); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 66, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannClassTypeContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { - return getRuleContext(UnannClassOrInterfaceTypeContext.class, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public UnannClassTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannClassType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannClassType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannClassTypeContext unannClassType() throws RecognitionException { - UnannClassTypeContext _localctx = new UnannClassTypeContext(_ctx, getState()); - enterRule(_localctx, 124, RULE_unannClassType); - int _la; - try { - setState(952); - switch (getInterpreter().adaptivePredict(_input, 70, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(936); - match(Identifier); - setState(938); - _la = _input.LA(1); - if (_la == LT) { - { - setState(937); - typeArguments(); - } - } - - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(940); - unannClassOrInterfaceType(); - setState(941); - match(DOT); - setState(945); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(942); - annotation(); - } - } - setState(947); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(948); - match(Identifier); - setState(950); - _la = _input.LA(1); - if (_la == LT) { - { - setState(949); - typeArguments(); - } - } - - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannClassType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public UnannClassType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannClassType_lf_unannClassOrInterfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannClassType_lf_unannClassOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() throws RecognitionException { - UnannClassType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lf_unannClassOrInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 126, RULE_unannClassType_lf_unannClassOrInterfaceType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(954); - match(DOT); - setState(958); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(955); - annotation(); - } - } - setState(960); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(961); - match(Identifier); - setState(963); - _la = _input.LA(1); - if (_la == LT) { - { - setState(962); - typeArguments(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannClassType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public UnannClassType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannClassType_lfno_unannClassOrInterfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannClassType_lfno_unannClassOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() throws RecognitionException { - UnannClassType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 128, RULE_unannClassType_lfno_unannClassOrInterfaceType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(965); - match(Identifier); - setState(967); - _la = _input.LA(1); - if (_la == LT) { - { - setState(966); - typeArguments(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannInterfaceTypeContext extends ParserRuleContext { - public UnannClassTypeContext unannClassType() { - return getRuleContext(UnannClassTypeContext.class, 0); - } - - public UnannInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannInterfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannInterfaceTypeContext unannInterfaceType() throws RecognitionException { - UnannInterfaceTypeContext _localctx = new UnannInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 130, RULE_unannInterfaceType); - try { - enterOuterAlt(_localctx, 1); - { - setState(969); - unannClassType(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannInterfaceType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext { - public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() { - return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class, 0); - } - - public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannInterfaceType_lf_unannClassOrInterfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannInterfaceType_lf_unannClassOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType() throws RecognitionException { - UnannInterfaceType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 132, RULE_unannInterfaceType_lf_unannClassOrInterfaceType); - try { - enterOuterAlt(_localctx, 1); - { - setState(971); - unannClassType_lf_unannClassOrInterfaceType(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext { - public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() { - return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class, 0); - } - - public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannInterfaceType_lfno_unannClassOrInterfaceType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannInterfaceType_lfno_unannClassOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() throws RecognitionException { - UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 134, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType); - try { - enterOuterAlt(_localctx, 1); - { - setState(973); - unannClassType_lfno_unannClassOrInterfaceType(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannTypeVariableContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public UnannTypeVariableContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannTypeVariable; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannTypeVariable(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannTypeVariableContext unannTypeVariable() throws RecognitionException { - UnannTypeVariableContext _localctx = new UnannTypeVariableContext(_ctx, getState()); - enterRule(_localctx, 136, RULE_unannTypeVariable); - try { - enterOuterAlt(_localctx, 1); - { - setState(975); - match(Identifier); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnannArrayTypeContext extends ParserRuleContext { - public UnannPrimitiveTypeContext unannPrimitiveType() { - return getRuleContext(UnannPrimitiveTypeContext.class, 0); - } - - public DimsContext dims() { - return getRuleContext(DimsContext.class, 0); - } - - public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { - return getRuleContext(UnannClassOrInterfaceTypeContext.class, 0); - } - - public UnannTypeVariableContext unannTypeVariable() { - return getRuleContext(UnannTypeVariableContext.class, 0); - } - - public UnannArrayTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unannArrayType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnannArrayType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnannArrayTypeContext unannArrayType() throws RecognitionException { - UnannArrayTypeContext _localctx = new UnannArrayTypeContext(_ctx, getState()); - enterRule(_localctx, 138, RULE_unannArrayType); - try { - setState(986); - switch (getInterpreter().adaptivePredict(_input, 74, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(977); - unannPrimitiveType(); - setState(978); - dims(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(980); - unannClassOrInterfaceType(); - setState(981); - dims(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(983); - unannTypeVariable(); - setState(984); - dims(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodDeclarationContext extends ParserRuleContext { - public MethodHeaderContext methodHeader() { - return getRuleContext(MethodHeaderContext.class, 0); - } - - public MethodBodyContext methodBody() { - return getRuleContext(MethodBodyContext.class, 0); - } - - public List<? extends MethodModifierContext> methodModifier() { - return getRuleContexts(MethodModifierContext.class); - } - - public MethodModifierContext methodModifier(int i) { - return getRuleContext(MethodModifierContext.class, i); - } - - public MethodDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodDeclarationContext methodDeclaration() throws RecognitionException { - MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState()); - enterRule(_localctx, 140, RULE_methodDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(991); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED))) != 0) || _la == AT) { - { - { - setState(988); - methodModifier(); - } - } - setState(993); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(994); - methodHeader(); - setState(995); - methodBody(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public MethodModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodModifierContext methodModifier() throws RecognitionException { - MethodModifierContext _localctx = new MethodModifierContext(_ctx, getState()); - enterRule(_localctx, 142, RULE_methodModifier); - try { - setState(1007); - switch (_input.LA(1)) { - case AT: - enterOuterAlt(_localctx, 1); - { - setState(997); - annotation(); - } - break; - case PUBLIC: - enterOuterAlt(_localctx, 2); - { - setState(998); - match(PUBLIC); - } - break; - case PROTECTED: - enterOuterAlt(_localctx, 3); - { - setState(999); - match(PROTECTED); - } - break; - case PRIVATE: - enterOuterAlt(_localctx, 4); - { - setState(1000); - match(PRIVATE); - } - break; - case ABSTRACT: - enterOuterAlt(_localctx, 5); - { - setState(1001); - match(ABSTRACT); - } - break; - case STATIC: - enterOuterAlt(_localctx, 6); - { - setState(1002); - match(STATIC); - } - break; - case FINAL: - enterOuterAlt(_localctx, 7); - { - setState(1003); - match(FINAL); - } - break; - case SYNCHRONIZED: - enterOuterAlt(_localctx, 8); - { - setState(1004); - match(SYNCHRONIZED); - } - break; - case NATIVE: - enterOuterAlt(_localctx, 9); - { - setState(1005); - match(NATIVE); - } - break; - case STRICTFP: - enterOuterAlt(_localctx, 10); - { - setState(1006); - match(STRICTFP); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodHeaderContext extends ParserRuleContext { - public ResultContext result() { - return getRuleContext(ResultContext.class, 0); - } - - public MethodDeclaratorContext methodDeclarator() { - return getRuleContext(MethodDeclaratorContext.class, 0); - } - - public Throws_Context throws_() { - return getRuleContext(Throws_Context.class, 0); - } - - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public MethodHeaderContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodHeader; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodHeader(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodHeaderContext methodHeader() throws RecognitionException { - MethodHeaderContext _localctx = new MethodHeaderContext(_ctx, getState()); - enterRule(_localctx, 144, RULE_methodHeader); - int _la; - try { - setState(1026); - switch (_input.LA(1)) { - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - case VOID: - case Identifier: - enterOuterAlt(_localctx, 1); - { - setState(1009); - result(); - setState(1010); - methodDeclarator(); - setState(1012); - _la = _input.LA(1); - if (_la == THROWS) { - { - setState(1011); - throws_(); - } - } - - } - break; - case LT: - enterOuterAlt(_localctx, 2); - { - setState(1014); - typeParameters(); - setState(1018); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(1015); - annotation(); - } - } - setState(1020); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1021); - result(); - setState(1022); - methodDeclarator(); - setState(1024); - _la = _input.LA(1); - if (_la == THROWS) { - { - setState(1023); - throws_(); - } - } - - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ResultContext extends ParserRuleContext { - public UnannTypeContext unannType() { - return getRuleContext(UnannTypeContext.class, 0); - } - - public ResultContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_result; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) return ((Java8Visitor<? extends Result>) visitor).visitResult(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ResultContext result() throws RecognitionException { - ResultContext _localctx = new ResultContext(_ctx, getState()); - enterRule(_localctx, 146, RULE_result); - try { - setState(1030); - switch (_input.LA(1)) { - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - case Identifier: - enterOuterAlt(_localctx, 1); - { - setState(1028); - unannType(); - } - break; - case VOID: - enterOuterAlt(_localctx, 2); - { - setState(1029); - match(VOID); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodDeclaratorContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public FormalParameterListContext formalParameterList() { - return getRuleContext(FormalParameterListContext.class, 0); - } - - public DimsContext dims() { - return getRuleContext(DimsContext.class, 0); - } - - public MethodDeclaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodDeclarator; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodDeclarator(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodDeclaratorContext methodDeclarator() throws RecognitionException { - MethodDeclaratorContext _localctx = new MethodDeclaratorContext(_ctx, getState()); - enterRule(_localctx, 148, RULE_methodDeclarator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1032); - match(Identifier); - setState(1033); - match(LPAREN); - setState(1035); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la == Identifier || _la == AT) { - { - setState(1034); - formalParameterList(); - } - } - - setState(1037); - match(RPAREN); - setState(1039); - _la = _input.LA(1); - if (_la == LBRACK || _la == AT) { - { - setState(1038); - dims(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class FormalParameterListContext extends ParserRuleContext { - public FormalParametersContext formalParameters() { - return getRuleContext(FormalParametersContext.class, 0); - } - - public LastFormalParameterContext lastFormalParameter() { - return getRuleContext(LastFormalParameterContext.class, 0); - } - - public FormalParameterListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_formalParameterList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitFormalParameterList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final FormalParameterListContext formalParameterList() throws RecognitionException { - FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState()); - enterRule(_localctx, 150, RULE_formalParameterList); - try { - setState(1046); - switch (getInterpreter().adaptivePredict(_input, 84, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1041); - formalParameters(); - setState(1042); - match(COMMA); - setState(1043); - lastFormalParameter(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1045); - lastFormalParameter(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class FormalParametersContext extends ParserRuleContext { - public List<? extends FormalParameterContext> formalParameter() { - return getRuleContexts(FormalParameterContext.class); - } - - public FormalParameterContext formalParameter(int i) { - return getRuleContext(FormalParameterContext.class, i); - } - - public ReceiverParameterContext receiverParameter() { - return getRuleContext(ReceiverParameterContext.class, 0); - } - - public FormalParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_formalParameters; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitFormalParameters(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final FormalParametersContext formalParameters() throws RecognitionException { - FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState()); - enterRule(_localctx, 152, RULE_formalParameters); - try { - int _alt; - setState(1064); - switch (getInterpreter().adaptivePredict(_input, 87, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1048); - formalParameter(); - setState(1053); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 85, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1049); - match(COMMA); - setState(1050); - formalParameter(); - } - } - } - setState(1055); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 85, _ctx); - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1056); - receiverParameter(); - setState(1061); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 86, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1057); - match(COMMA); - setState(1058); - formalParameter(); - } - } - } - setState(1063); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 86, _ctx); - } - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class FormalParameterContext extends ParserRuleContext { - public UnannTypeContext unannType() { - return getRuleContext(UnannTypeContext.class, 0); - } - - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public List<? extends VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public FormalParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_formalParameter; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitFormalParameter(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final FormalParameterContext formalParameter() throws RecognitionException { - FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState()); - enterRule(_localctx, 154, RULE_formalParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1069); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == FINAL || _la == AT) { - { - { - setState(1066); - variableModifier(); - } - } - setState(1071); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1072); - unannType(); - setState(1073); - variableDeclaratorId(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class VariableModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public VariableModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_variableModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitVariableModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final VariableModifierContext variableModifier() throws RecognitionException { - VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState()); - enterRule(_localctx, 156, RULE_variableModifier); - try { - setState(1077); - switch (_input.LA(1)) { - case AT: - enterOuterAlt(_localctx, 1); - { - setState(1075); - annotation(); - } - break; - case FINAL: - enterOuterAlt(_localctx, 2); - { - setState(1076); - match(FINAL); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class LastFormalParameterContext extends ParserRuleContext { - public UnannTypeContext unannType() { - return getRuleContext(UnannTypeContext.class, 0); - } - - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public List<? extends VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public FormalParameterContext formalParameter() { - return getRuleContext(FormalParameterContext.class, 0); - } - - public LastFormalParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_lastFormalParameter; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitLastFormalParameter(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final LastFormalParameterContext lastFormalParameter() throws RecognitionException { - LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState()); - enterRule(_localctx, 158, RULE_lastFormalParameter); - int _la; - try { - setState(1096); - switch (getInterpreter().adaptivePredict(_input, 92, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1082); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == FINAL || _la == AT) { - { - { - setState(1079); - variableModifier(); - } - } - setState(1084); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1085); - unannType(); - setState(1089); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(1086); - annotation(); - } - } - setState(1091); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1092); - match(ELLIPSIS); - setState(1093); - variableDeclaratorId(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1095); - formalParameter(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ReceiverParameterContext extends ParserRuleContext { - public UnannTypeContext unannType() { - return getRuleContext(UnannTypeContext.class, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public ReceiverParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_receiverParameter; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitReceiverParameter(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ReceiverParameterContext receiverParameter() throws RecognitionException { - ReceiverParameterContext _localctx = new ReceiverParameterContext(_ctx, getState()); - enterRule(_localctx, 160, RULE_receiverParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1101); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(1098); - annotation(); - } - } - setState(1103); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1104); - unannType(); - setState(1107); - _la = _input.LA(1); - if (_la == Identifier) { - { - setState(1105); - match(Identifier); - setState(1106); - match(DOT); - } - } - - setState(1109); - match(THIS); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Throws_Context extends ParserRuleContext { - public ExceptionTypeListContext exceptionTypeList() { - return getRuleContext(ExceptionTypeListContext.class, 0); - } - - public Throws_Context(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_throws_; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitThrows_(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final Throws_Context throws_() throws RecognitionException { - Throws_Context _localctx = new Throws_Context(_ctx, getState()); - enterRule(_localctx, 162, RULE_throws_); - try { - enterOuterAlt(_localctx, 1); - { - setState(1111); - match(THROWS); - setState(1112); - exceptionTypeList(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ExceptionTypeListContext extends ParserRuleContext { - public List<? extends ExceptionTypeContext> exceptionType() { - return getRuleContexts(ExceptionTypeContext.class); - } - - public ExceptionTypeContext exceptionType(int i) { - return getRuleContext(ExceptionTypeContext.class, i); - } - - public ExceptionTypeListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_exceptionTypeList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitExceptionTypeList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ExceptionTypeListContext exceptionTypeList() throws RecognitionException { - ExceptionTypeListContext _localctx = new ExceptionTypeListContext(_ctx, getState()); - enterRule(_localctx, 164, RULE_exceptionTypeList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1114); - exceptionType(); - setState(1119); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(1115); - match(COMMA); - setState(1116); - exceptionType(); - } - } - setState(1121); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ExceptionTypeContext extends ParserRuleContext { - public ClassTypeContext classType() { - return getRuleContext(ClassTypeContext.class, 0); - } - - public TypeVariableContext typeVariable() { - return getRuleContext(TypeVariableContext.class, 0); - } - - public ExceptionTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_exceptionType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitExceptionType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ExceptionTypeContext exceptionType() throws RecognitionException { - ExceptionTypeContext _localctx = new ExceptionTypeContext(_ctx, getState()); - enterRule(_localctx, 166, RULE_exceptionType); - try { - setState(1124); - switch (getInterpreter().adaptivePredict(_input, 96, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1122); - classType(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1123); - typeVariable(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodBodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public MethodBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodBody; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodBody(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodBodyContext methodBody() throws RecognitionException { - MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState()); - enterRule(_localctx, 168, RULE_methodBody); - try { - setState(1128); - switch (_input.LA(1)) { - case LBRACE: - enterOuterAlt(_localctx, 1); - { - setState(1126); - block(); - } - break; - case SEMI: - enterOuterAlt(_localctx, 2); - { - setState(1127); - match(SEMI); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InstanceInitializerContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public InstanceInitializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_instanceInitializer; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInstanceInitializer(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InstanceInitializerContext instanceInitializer() throws RecognitionException { - InstanceInitializerContext _localctx = new InstanceInitializerContext(_ctx, getState()); - enterRule(_localctx, 170, RULE_instanceInitializer); - try { - enterOuterAlt(_localctx, 1); - { - setState(1130); - block(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class StaticInitializerContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public StaticInitializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_staticInitializer; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitStaticInitializer(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final StaticInitializerContext staticInitializer() throws RecognitionException { - StaticInitializerContext _localctx = new StaticInitializerContext(_ctx, getState()); - enterRule(_localctx, 172, RULE_staticInitializer); - try { - enterOuterAlt(_localctx, 1); - { - setState(1132); - match(STATIC); - setState(1133); - block(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ConstructorDeclarationContext extends ParserRuleContext { - public ConstructorDeclaratorContext constructorDeclarator() { - return getRuleContext(ConstructorDeclaratorContext.class, 0); - } - - public ConstructorBodyContext constructorBody() { - return getRuleContext(ConstructorBodyContext.class, 0); - } - - public List<? extends ConstructorModifierContext> constructorModifier() { - return getRuleContexts(ConstructorModifierContext.class); - } - - public ConstructorModifierContext constructorModifier(int i) { - return getRuleContext(ConstructorModifierContext.class, i); - } - - public Throws_Context throws_() { - return getRuleContext(Throws_Context.class, 0); - } - - public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_constructorDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitConstructorDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException { - ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState()); - enterRule(_localctx, 174, RULE_constructorDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1138); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || _la == AT) { - { - { - setState(1135); - constructorModifier(); - } - } - setState(1140); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1141); - constructorDeclarator(); - setState(1143); - _la = _input.LA(1); - if (_la == THROWS) { - { - setState(1142); - throws_(); - } - } - - setState(1145); - constructorBody(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ConstructorModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public ConstructorModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_constructorModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitConstructorModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ConstructorModifierContext constructorModifier() throws RecognitionException { - ConstructorModifierContext _localctx = new ConstructorModifierContext(_ctx, getState()); - enterRule(_localctx, 176, RULE_constructorModifier); - try { - setState(1151); - switch (_input.LA(1)) { - case AT: - enterOuterAlt(_localctx, 1); - { - setState(1147); - annotation(); - } - break; - case PUBLIC: - enterOuterAlt(_localctx, 2); - { - setState(1148); - match(PUBLIC); - } - break; - case PROTECTED: - enterOuterAlt(_localctx, 3); - { - setState(1149); - match(PROTECTED); - } - break; - case PRIVATE: - enterOuterAlt(_localctx, 4); - { - setState(1150); - match(PRIVATE); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ConstructorDeclaratorContext extends ParserRuleContext { - public SimpleTypeNameContext simpleTypeName() { - return getRuleContext(SimpleTypeNameContext.class, 0); - } - - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class, 0); - } - - public FormalParameterListContext formalParameterList() { - return getRuleContext(FormalParameterListContext.class, 0); - } - - public ConstructorDeclaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_constructorDeclarator; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitConstructorDeclarator(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ConstructorDeclaratorContext constructorDeclarator() throws RecognitionException { - ConstructorDeclaratorContext _localctx = new ConstructorDeclaratorContext(_ctx, getState()); - enterRule(_localctx, 178, RULE_constructorDeclarator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1154); - _la = _input.LA(1); - if (_la == LT) { - { - setState(1153); - typeParameters(); - } - } - - setState(1156); - simpleTypeName(); - setState(1157); - match(LPAREN); - setState(1159); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la == Identifier || _la == AT) { - { - setState(1158); - formalParameterList(); - } - } - - setState(1161); - match(RPAREN); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SimpleTypeNameContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public SimpleTypeNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_simpleTypeName; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSimpleTypeName(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SimpleTypeNameContext simpleTypeName() throws RecognitionException { - SimpleTypeNameContext _localctx = new SimpleTypeNameContext(_ctx, getState()); - enterRule(_localctx, 180, RULE_simpleTypeName); - try { - enterOuterAlt(_localctx, 1); - { - setState(1163); - match(Identifier); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ConstructorBodyContext extends ParserRuleContext { - public ExplicitConstructorInvocationContext explicitConstructorInvocation() { - return getRuleContext(ExplicitConstructorInvocationContext.class, 0); - } - - public BlockStatementsContext blockStatements() { - return getRuleContext(BlockStatementsContext.class, 0); - } - - public ConstructorBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_constructorBody; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitConstructorBody(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ConstructorBodyContext constructorBody() throws RecognitionException { - ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState()); - enterRule(_localctx, 182, RULE_constructorBody); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1165); - match(LBRACE); - setState(1167); - switch (getInterpreter().adaptivePredict(_input, 103, _ctx)) { - case 1: { - setState(1166); - explicitConstructorInvocation(); - } - break; - } - setState(1170); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SW [...] - { - setState(1169); - blockStatements(); - } - } - - setState(1172); - match(RBRACE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ExplicitConstructorInvocationContext extends ParserRuleContext { - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public ArgumentListContext argumentList() { - return getRuleContext(ArgumentListContext.class, 0); - } - - public ExpressionNameContext expressionName() { - return getRuleContext(ExpressionNameContext.class, 0); - } - - public PrimaryContext primary() { - return getRuleContext(PrimaryContext.class, 0); - } - - public ExplicitConstructorInvocationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_explicitConstructorInvocation; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitExplicitConstructorInvocation(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ExplicitConstructorInvocationContext explicitConstructorInvocation() throws RecognitionException { - ExplicitConstructorInvocationContext _localctx = new ExplicitConstructorInvocationContext(_ctx, getState()); - enterRule(_localctx, 184, RULE_explicitConstructorInvocation); - int _la; - try { - setState(1220); - switch (getInterpreter().adaptivePredict(_input, 113, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1175); - _la = _input.LA(1); - if (_la == LT) { - { - setState(1174); - typeArguments(); - } - } - - setState(1177); - match(THIS); - setState(1178); - match(LPAREN); - setState(1180); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(1179); - argumentList(); - } - } - - setState(1182); - match(RPAREN); - setState(1183); - match(SEMI); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1185); - _la = _input.LA(1); - if (_la == LT) { - { - setState(1184); - typeArguments(); - } - } - - setState(1187); - match(SUPER); - setState(1188); - match(LPAREN); - setState(1190); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(1189); - argumentList(); - } - } - - setState(1192); - match(RPAREN); - setState(1193); - match(SEMI); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1194); - expressionName(); - setState(1195); - match(DOT); - setState(1197); - _la = _input.LA(1); - if (_la == LT) { - { - setState(1196); - typeArguments(); - } - } - - setState(1199); - match(SUPER); - setState(1200); - match(LPAREN); - setState(1202); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(1201); - argumentList(); - } - } - - setState(1204); - match(RPAREN); - setState(1205); - match(SEMI); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1207); - primary(); - setState(1208); - match(DOT); - setState(1210); - _la = _input.LA(1); - if (_la == LT) { - { - setState(1209); - typeArguments(); - } - } - - setState(1212); - match(SUPER); - setState(1213); - match(LPAREN); - setState(1215); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(1214); - argumentList(); - } - } - - setState(1217); - match(RPAREN); - setState(1218); - match(SEMI); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class EnumDeclarationContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public EnumBodyContext enumBody() { - return getRuleContext(EnumBodyContext.class, 0); - } - - public List<? extends ClassModifierContext> classModifier() { - return getRuleContexts(ClassModifierContext.class); - } - - public ClassModifierContext classModifier(int i) { - return getRuleContext(ClassModifierContext.class, i); - } - - public SuperinterfacesContext superinterfaces() { - return getRuleContext(SuperinterfacesContext.class, 0); - } - - public EnumDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enumDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitEnumDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final EnumDeclarationContext enumDeclaration() throws RecognitionException { - EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState()); - enterRule(_localctx, 186, RULE_enumDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1225); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la == AT) { - { - { - setState(1222); - classModifier(); - } - } - setState(1227); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1228); - match(ENUM); - setState(1229); - match(Identifier); - setState(1231); - _la = _input.LA(1); - if (_la == IMPLEMENTS) { - { - setState(1230); - superinterfaces(); - } - } - - setState(1233); - enumBody(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class EnumBodyContext extends ParserRuleContext { - public EnumConstantListContext enumConstantList() { - return getRuleContext(EnumConstantListContext.class, 0); - } - - public EnumBodyDeclarationsContext enumBodyDeclarations() { - return getRuleContext(EnumBodyDeclarationsContext.class, 0); - } - - public EnumBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enumBody; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitEnumBody(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final EnumBodyContext enumBody() throws RecognitionException { - EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState()); - enterRule(_localctx, 188, RULE_enumBody); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1235); - match(LBRACE); - setState(1237); - _la = _input.LA(1); - if (_la == Identifier || _la == AT) { - { - setState(1236); - enumConstantList(); - } - } - - setState(1240); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(1239); - match(COMMA); - } - } - - setState(1243); - _la = _input.LA(1); - if (_la == SEMI) { - { - setState(1242); - enumBodyDeclarations(); - } - } - - setState(1245); - match(RBRACE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class EnumConstantListContext extends ParserRuleContext { - public List<? extends EnumConstantContext> enumConstant() { - return getRuleContexts(EnumConstantContext.class); - } - - public EnumConstantContext enumConstant(int i) { - return getRuleContext(EnumConstantContext.class, i); - } - - public EnumConstantListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enumConstantList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitEnumConstantList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final EnumConstantListContext enumConstantList() throws RecognitionException { - EnumConstantListContext _localctx = new EnumConstantListContext(_ctx, getState()); - enterRule(_localctx, 190, RULE_enumConstantList); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1247); - enumConstant(); - setState(1252); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 119, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1248); - match(COMMA); - setState(1249); - enumConstant(); - } - } - } - setState(1254); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 119, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class EnumConstantContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public List<? extends EnumConstantModifierContext> enumConstantModifier() { - return getRuleContexts(EnumConstantModifierContext.class); - } - - public EnumConstantModifierContext enumConstantModifier(int i) { - return getRuleContext(EnumConstantModifierContext.class, i); - } - - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class, 0); - } - - public ArgumentListContext argumentList() { - return getRuleContext(ArgumentListContext.class, 0); - } - - public EnumConstantContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enumConstant; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitEnumConstant(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final EnumConstantContext enumConstant() throws RecognitionException { - EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState()); - enterRule(_localctx, 192, RULE_enumConstant); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1258); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(1255); - enumConstantModifier(); - } - } - setState(1260); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1261); - match(Identifier); - setState(1267); - _la = _input.LA(1); - if (_la == LPAREN) { - { - setState(1262); - match(LPAREN); - setState(1264); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1 [...] - { - setState(1263); - argumentList(); - } - } - - setState(1266); - match(RPAREN); - } - } - - setState(1270); - _la = _input.LA(1); - if (_la == LBRACE) { - { - setState(1269); - classBody(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class EnumConstantModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public EnumConstantModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enumConstantModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitEnumConstantModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final EnumConstantModifierContext enumConstantModifier() throws RecognitionException { - EnumConstantModifierContext _localctx = new EnumConstantModifierContext(_ctx, getState()); - enterRule(_localctx, 194, RULE_enumConstantModifier); - try { - enterOuterAlt(_localctx, 1); - { - setState(1272); - annotation(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class EnumBodyDeclarationsContext extends ParserRuleContext { - public List<? extends ClassBodyDeclarationContext> classBodyDeclaration() { - return getRuleContexts(ClassBodyDeclarationContext.class); - } - - public ClassBodyDeclarationContext classBodyDeclaration(int i) { - return getRuleContext(ClassBodyDeclarationContext.class, i); - } - - public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enumBodyDeclarations; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitEnumBodyDeclarations(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException { - EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState()); - enterRule(_localctx, 196, RULE_enumBodyDeclarations); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1274); - match(SEMI); - setState(1278); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << LBRACE) | (1L << SEMI))) [...] - { - { - setState(1275); - classBodyDeclaration(); - } - } - setState(1280); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceDeclarationContext extends ParserRuleContext { - public NormalInterfaceDeclarationContext normalInterfaceDeclaration() { - return getRuleContext(NormalInterfaceDeclarationContext.class, 0); - } - - public AnnotationTypeDeclarationContext annotationTypeDeclaration() { - return getRuleContext(AnnotationTypeDeclarationContext.class, 0); - } - - public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInterfaceDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException { - InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState()); - enterRule(_localctx, 198, RULE_interfaceDeclaration); - try { - setState(1283); - switch (getInterpreter().adaptivePredict(_input, 125, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1281); - normalInterfaceDeclaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1282); - annotationTypeDeclaration(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class NormalInterfaceDeclarationContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public InterfaceBodyContext interfaceBody() { - return getRuleContext(InterfaceBodyContext.class, 0); - } - - public List<? extends InterfaceModifierContext> interfaceModifier() { - return getRuleContexts(InterfaceModifierContext.class); - } - - public InterfaceModifierContext interfaceModifier(int i) { - return getRuleContext(InterfaceModifierContext.class, i); - } - - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class, 0); - } - - public ExtendsInterfacesContext extendsInterfaces() { - return getRuleContext(ExtendsInterfacesContext.class, 0); - } - - public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_normalInterfaceDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitNormalInterfaceDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final NormalInterfaceDeclarationContext normalInterfaceDeclaration() throws RecognitionException { - NormalInterfaceDeclarationContext _localctx = new NormalInterfaceDeclarationContext(_ctx, getState()); - enterRule(_localctx, 200, RULE_normalInterfaceDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1288); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la == AT) { - { - { - setState(1285); - interfaceModifier(); - } - } - setState(1290); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1291); - match(INTERFACE); - setState(1292); - match(Identifier); - setState(1294); - _la = _input.LA(1); - if (_la == LT) { - { - setState(1293); - typeParameters(); - } - } - - setState(1297); - _la = _input.LA(1); - if (_la == EXTENDS) { - { - setState(1296); - extendsInterfaces(); - } - } - - setState(1299); - interfaceBody(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public InterfaceModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInterfaceModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InterfaceModifierContext interfaceModifier() throws RecognitionException { - InterfaceModifierContext _localctx = new InterfaceModifierContext(_ctx, getState()); - enterRule(_localctx, 202, RULE_interfaceModifier); - try { - setState(1308); - switch (_input.LA(1)) { - case AT: - enterOuterAlt(_localctx, 1); - { - setState(1301); - annotation(); - } - break; - case PUBLIC: - enterOuterAlt(_localctx, 2); - { - setState(1302); - match(PUBLIC); - } - break; - case PROTECTED: - enterOuterAlt(_localctx, 3); - { - setState(1303); - match(PROTECTED); - } - break; - case PRIVATE: - enterOuterAlt(_localctx, 4); - { - setState(1304); - match(PRIVATE); - } - break; - case ABSTRACT: - enterOuterAlt(_localctx, 5); - { - setState(1305); - match(ABSTRACT); - } - break; - case STATIC: - enterOuterAlt(_localctx, 6); - { - setState(1306); - match(STATIC); - } - break; - case STRICTFP: - enterOuterAlt(_localctx, 7); - { - setState(1307); - match(STRICTFP); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ExtendsInterfacesContext extends ParserRuleContext { - public InterfaceTypeListContext interfaceTypeList() { - return getRuleContext(InterfaceTypeListContext.class, 0); - } - - public ExtendsInterfacesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_extendsInterfaces; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitExtendsInterfaces(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ExtendsInterfacesContext extendsInterfaces() throws RecognitionException { - ExtendsInterfacesContext _localctx = new ExtendsInterfacesContext(_ctx, getState()); - enterRule(_localctx, 204, RULE_extendsInterfaces); - try { - enterOuterAlt(_localctx, 1); - { - setState(1310); - match(EXTENDS); - setState(1311); - interfaceTypeList(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceBodyContext extends ParserRuleContext { - public List<? extends InterfaceMemberDeclarationContext> interfaceMemberDeclaration() { - return getRuleContexts(InterfaceMemberDeclarationContext.class); - } - - public InterfaceMemberDeclarationContext interfaceMemberDeclaration(int i) { - return getRuleContext(InterfaceMemberDeclarationContext.class, i); - } - - public InterfaceBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceBody; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInterfaceBody(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InterfaceBodyContext interfaceBody() throws RecognitionException { - InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState()); - enterRule(_localctx, 206, RULE_interfaceBody); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1313); - match(LBRACE); - setState(1317); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DEFAULT) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << VOID) | (1L << SEMI))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - [...] - { - { - setState(1314); - interfaceMemberDeclaration(); - } - } - setState(1319); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1320); - match(RBRACE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceMemberDeclarationContext extends ParserRuleContext { - public ConstantDeclarationContext constantDeclaration() { - return getRuleContext(ConstantDeclarationContext.class, 0); - } - - public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { - return getRuleContext(InterfaceMethodDeclarationContext.class, 0); - } - - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class, 0); - } - - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class, 0); - } - - public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceMemberDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInterfaceMemberDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException { - InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState()); - enterRule(_localctx, 208, RULE_interfaceMemberDeclaration); - try { - setState(1327); - switch (getInterpreter().adaptivePredict(_input, 131, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1322); - constantDeclaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1323); - interfaceMethodDeclaration(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1324); - classDeclaration(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1325); - interfaceDeclaration(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1326); - match(SEMI); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ConstantDeclarationContext extends ParserRuleContext { - public UnannTypeContext unannType() { - return getRuleContext(UnannTypeContext.class, 0); - } - - public VariableDeclaratorListContext variableDeclaratorList() { - return getRuleContext(VariableDeclaratorListContext.class, 0); - } - - public List<? extends ConstantModifierContext> constantModifier() { - return getRuleContexts(ConstantModifierContext.class); - } - - public ConstantModifierContext constantModifier(int i) { - return getRuleContext(ConstantModifierContext.class, i); - } - - public ConstantDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_constantDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitConstantDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ConstantDeclarationContext constantDeclaration() throws RecognitionException { - ConstantDeclarationContext _localctx = new ConstantDeclarationContext(_ctx, getState()); - enterRule(_localctx, 210, RULE_constantDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1332); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FINAL) | (1L << PUBLIC) | (1L << STATIC))) != 0) || _la == AT) { - { - { - setState(1329); - constantModifier(); - } - } - setState(1334); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1335); - unannType(); - setState(1336); - variableDeclaratorList(); - setState(1337); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ConstantModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public ConstantModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_constantModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitConstantModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ConstantModifierContext constantModifier() throws RecognitionException { - ConstantModifierContext _localctx = new ConstantModifierContext(_ctx, getState()); - enterRule(_localctx, 212, RULE_constantModifier); - try { - setState(1343); - switch (_input.LA(1)) { - case AT: - enterOuterAlt(_localctx, 1); - { - setState(1339); - annotation(); - } - break; - case PUBLIC: - enterOuterAlt(_localctx, 2); - { - setState(1340); - match(PUBLIC); - } - break; - case STATIC: - enterOuterAlt(_localctx, 3); - { - setState(1341); - match(STATIC); - } - break; - case FINAL: - enterOuterAlt(_localctx, 4); - { - setState(1342); - match(FINAL); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceMethodDeclarationContext extends ParserRuleContext { - public MethodHeaderContext methodHeader() { - return getRuleContext(MethodHeaderContext.class, 0); - } - - public MethodBodyContext methodBody() { - return getRuleContext(MethodBodyContext.class, 0); - } - - public List<? extends InterfaceMethodModifierContext> interfaceMethodModifier() { - return getRuleContexts(InterfaceMethodModifierContext.class); - } - - public InterfaceMethodModifierContext interfaceMethodModifier(int i) { - return getRuleContext(InterfaceMethodModifierContext.class, i); - } - - public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceMethodDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInterfaceMethodDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException { - InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState()); - enterRule(_localctx, 214, RULE_interfaceMethodDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1348); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << DEFAULT) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la == AT) { - { - { - setState(1345); - interfaceMethodModifier(); - } - } - setState(1350); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1351); - methodHeader(); - setState(1352); - methodBody(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceMethodModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceMethodModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInterfaceMethodModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException { - InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState()); - enterRule(_localctx, 216, RULE_interfaceMethodModifier); - try { - setState(1360); - switch (_input.LA(1)) { - case AT: - enterOuterAlt(_localctx, 1); - { - setState(1354); - annotation(); - } - break; - case PUBLIC: - enterOuterAlt(_localctx, 2); - { - setState(1355); - match(PUBLIC); - } - break; - case ABSTRACT: - enterOuterAlt(_localctx, 3); - { - setState(1356); - match(ABSTRACT); - } - break; - case DEFAULT: - enterOuterAlt(_localctx, 4); - { - setState(1357); - match(DEFAULT); - } - break; - case STATIC: - enterOuterAlt(_localctx, 5); - { - setState(1358); - match(STATIC); - } - break; - case STRICTFP: - enterOuterAlt(_localctx, 6); - { - setState(1359); - match(STRICTFP); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationTypeDeclarationContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public AnnotationTypeBodyContext annotationTypeBody() { - return getRuleContext(AnnotationTypeBodyContext.class, 0); - } - - public List<? extends InterfaceModifierContext> interfaceModifier() { - return getRuleContexts(InterfaceModifierContext.class); - } - - public InterfaceModifierContext interfaceModifier(int i) { - return getRuleContext(InterfaceModifierContext.class, i); - } - - public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationTypeDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAnnotationTypeDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException { - AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState()); - enterRule(_localctx, 218, RULE_annotationTypeDeclaration); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1365); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 136, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1362); - interfaceModifier(); - } - } - } - setState(1367); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 136, _ctx); - } - setState(1368); - match(AT); - setState(1369); - match(INTERFACE); - setState(1370); - match(Identifier); - setState(1371); - annotationTypeBody(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationTypeBodyContext extends ParserRuleContext { - public List<? extends AnnotationTypeMemberDeclarationContext> annotationTypeMemberDeclaration() { - return getRuleContexts(AnnotationTypeMemberDeclarationContext.class); - } - - public AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration(int i) { - return getRuleContext(AnnotationTypeMemberDeclarationContext.class, i); - } - - public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationTypeBody; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAnnotationTypeBody(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException { - AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState()); - enterRule(_localctx, 220, RULE_annotationTypeBody); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1373); - match(LBRACE); - setState(1377); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SEMI))) != 0) || _la == Identifier || _la == AT) { - { - { - setState(1374); - annotationTypeMemberDeclaration(); - } - } - setState(1379); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1380); - match(RBRACE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationTypeMemberDeclarationContext extends ParserRuleContext { - public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() { - return getRuleContext(AnnotationTypeElementDeclarationContext.class, 0); - } - - public ConstantDeclarationContext constantDeclaration() { - return getRuleContext(ConstantDeclarationContext.class, 0); - } - - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class, 0); - } - - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class, 0); - } - - public AnnotationTypeMemberDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationTypeMemberDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAnnotationTypeMemberDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration() throws RecognitionException { - AnnotationTypeMemberDeclarationContext _localctx = new AnnotationTypeMemberDeclarationContext(_ctx, getState()); - enterRule(_localctx, 222, RULE_annotationTypeMemberDeclaration); - try { - setState(1387); - switch (getInterpreter().adaptivePredict(_input, 138, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1382); - annotationTypeElementDeclaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1383); - constantDeclaration(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1384); - classDeclaration(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1385); - interfaceDeclaration(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1386); - match(SEMI); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext { - public UnannTypeContext unannType() { - return getRuleContext(UnannTypeContext.class, 0); - } - - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public List<? extends AnnotationTypeElementModifierContext> annotationTypeElementModifier() { - return getRuleContexts(AnnotationTypeElementModifierContext.class); - } - - public AnnotationTypeElementModifierContext annotationTypeElementModifier(int i) { - return getRuleContext(AnnotationTypeElementModifierContext.class, i); - } - - public DimsContext dims() { - return getRuleContext(DimsContext.class, 0); - } - - public DefaultValueContext defaultValue() { - return getRuleContext(DefaultValueContext.class, 0); - } - - public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationTypeElementDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAnnotationTypeElementDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException { - AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState()); - enterRule(_localctx, 224, RULE_annotationTypeElementDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1392); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == ABSTRACT || _la == PUBLIC || _la == AT) { - { - { - setState(1389); - annotationTypeElementModifier(); - } - } - setState(1394); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1395); - unannType(); - setState(1396); - match(Identifier); - setState(1397); - match(LPAREN); - setState(1398); - match(RPAREN); - setState(1400); - _la = _input.LA(1); - if (_la == LBRACK || _la == AT) { - { - setState(1399); - dims(); - } - } - - setState(1403); - _la = _input.LA(1); - if (_la == DEFAULT) { - { - setState(1402); - defaultValue(); - } - } - - setState(1405); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationTypeElementModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public AnnotationTypeElementModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationTypeElementModifier; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAnnotationTypeElementModifier(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AnnotationTypeElementModifierContext annotationTypeElementModifier() throws RecognitionException { - AnnotationTypeElementModifierContext _localctx = new AnnotationTypeElementModifierContext(_ctx, getState()); - enterRule(_localctx, 226, RULE_annotationTypeElementModifier); - try { - setState(1410); - switch (_input.LA(1)) { - case AT: - enterOuterAlt(_localctx, 1); - { - setState(1407); - annotation(); - } - break; - case PUBLIC: - enterOuterAlt(_localctx, 2); - { - setState(1408); - match(PUBLIC); - } - break; - case ABSTRACT: - enterOuterAlt(_localctx, 3); - { - setState(1409); - match(ABSTRACT); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class DefaultValueContext extends ParserRuleContext { - public ElementValueContext elementValue() { - return getRuleContext(ElementValueContext.class, 0); - } - - public DefaultValueContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_defaultValue; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitDefaultValue(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final DefaultValueContext defaultValue() throws RecognitionException { - DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState()); - enterRule(_localctx, 228, RULE_defaultValue); - try { - enterOuterAlt(_localctx, 1); - { - setState(1412); - match(DEFAULT); - setState(1413); - elementValue(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationContext extends ParserRuleContext { - public NormalAnnotationContext normalAnnotation() { - return getRuleContext(NormalAnnotationContext.class, 0); - } - - public MarkerAnnotationContext markerAnnotation() { - return getRuleContext(MarkerAnnotationContext.class, 0); - } - - public SingleElementAnnotationContext singleElementAnnotation() { - return getRuleContext(SingleElementAnnotationContext.class, 0); - } - - public AnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotation; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAnnotation(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AnnotationContext annotation() throws RecognitionException { - AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); - enterRule(_localctx, 230, RULE_annotation); - try { - setState(1418); - switch (getInterpreter().adaptivePredict(_input, 143, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1415); - normalAnnotation(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1416); - markerAnnotation(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1417); - singleElementAnnotation(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class NormalAnnotationContext extends ParserRuleContext { - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public ElementValuePairListContext elementValuePairList() { - return getRuleContext(ElementValuePairListContext.class, 0); - } - - public NormalAnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_normalAnnotation; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitNormalAnnotation(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final NormalAnnotationContext normalAnnotation() throws RecognitionException { - NormalAnnotationContext _localctx = new NormalAnnotationContext(_ctx, getState()); - enterRule(_localctx, 232, RULE_normalAnnotation); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1420); - match(AT); - setState(1421); - typeName(); - setState(1422); - match(LPAREN); - setState(1424); - _la = _input.LA(1); - if (_la == Identifier) { - { - setState(1423); - elementValuePairList(); - } - } - - setState(1426); - match(RPAREN); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ElementValuePairListContext extends ParserRuleContext { - public List<? extends ElementValuePairContext> elementValuePair() { - return getRuleContexts(ElementValuePairContext.class); - } - - public ElementValuePairContext elementValuePair(int i) { - return getRuleContext(ElementValuePairContext.class, i); - } - - public ElementValuePairListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_elementValuePairList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitElementValuePairList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ElementValuePairListContext elementValuePairList() throws RecognitionException { - ElementValuePairListContext _localctx = new ElementValuePairListContext(_ctx, getState()); - enterRule(_localctx, 234, RULE_elementValuePairList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1428); - elementValuePair(); - setState(1433); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(1429); - match(COMMA); - setState(1430); - elementValuePair(); - } - } - setState(1435); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ElementValuePairContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public ElementValueContext elementValue() { - return getRuleContext(ElementValueContext.class, 0); - } - - public ElementValuePairContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_elementValuePair; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitElementValuePair(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ElementValuePairContext elementValuePair() throws RecognitionException { - ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState()); - enterRule(_localctx, 236, RULE_elementValuePair); - try { - enterOuterAlt(_localctx, 1); - { - setState(1436); - match(Identifier); - setState(1437); - match(ASSIGN); - setState(1438); - elementValue(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ElementValueContext extends ParserRuleContext { - public ConditionalExpressionContext conditionalExpression() { - return getRuleContext(ConditionalExpressionContext.class, 0); - } - - public ElementValueArrayInitializerContext elementValueArrayInitializer() { - return getRuleContext(ElementValueArrayInitializerContext.class, 0); - } - - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public ElementValueContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_elementValue; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitElementValue(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ElementValueContext elementValue() throws RecognitionException { - ElementValueContext _localctx = new ElementValueContext(_ctx, getState()); - enterRule(_localctx, 238, RULE_elementValue); - try { - setState(1443); - switch (getInterpreter().adaptivePredict(_input, 146, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1440); - conditionalExpression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1441); - elementValueArrayInitializer(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1442); - annotation(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ElementValueArrayInitializerContext extends ParserRuleContext { - public ElementValueListContext elementValueList() { - return getRuleContext(ElementValueListContext.class, 0); - } - - public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_elementValueArrayInitializer; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitElementValueArrayInitializer(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException { - ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState()); - enterRule(_localctx, 240, RULE_elementValueArrayInitializer); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1445); - match(LBRACE); - setState(1447); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN) | (1L << LBRACE))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 6 [...] - { - setState(1446); - elementValueList(); - } - } - - setState(1450); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(1449); - match(COMMA); - } - } - - setState(1452); - match(RBRACE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ElementValueListContext extends ParserRuleContext { - public List<? extends ElementValueContext> elementValue() { - return getRuleContexts(ElementValueContext.class); - } - - public ElementValueContext elementValue(int i) { - return getRuleContext(ElementValueContext.class, i); - } - - public ElementValueListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_elementValueList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitElementValueList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ElementValueListContext elementValueList() throws RecognitionException { - ElementValueListContext _localctx = new ElementValueListContext(_ctx, getState()); - enterRule(_localctx, 242, RULE_elementValueList); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1454); - elementValue(); - setState(1459); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 149, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1455); - match(COMMA); - setState(1456); - elementValue(); - } - } - } - setState(1461); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 149, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MarkerAnnotationContext extends ParserRuleContext { - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public MarkerAnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_markerAnnotation; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMarkerAnnotation(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MarkerAnnotationContext markerAnnotation() throws RecognitionException { - MarkerAnnotationContext _localctx = new MarkerAnnotationContext(_ctx, getState()); - enterRule(_localctx, 244, RULE_markerAnnotation); - try { - enterOuterAlt(_localctx, 1); - { - setState(1462); - match(AT); - setState(1463); - typeName(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SingleElementAnnotationContext extends ParserRuleContext { - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public ElementValueContext elementValue() { - return getRuleContext(ElementValueContext.class, 0); - } - - public SingleElementAnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_singleElementAnnotation; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSingleElementAnnotation(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SingleElementAnnotationContext singleElementAnnotation() throws RecognitionException { - SingleElementAnnotationContext _localctx = new SingleElementAnnotationContext(_ctx, getState()); - enterRule(_localctx, 246, RULE_singleElementAnnotation); - try { - enterOuterAlt(_localctx, 1); - { - setState(1465); - match(AT); - setState(1466); - typeName(); - setState(1467); - match(LPAREN); - setState(1468); - elementValue(); - setState(1469); - match(RPAREN); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ArrayInitializerContext extends ParserRuleContext { - public VariableInitializerListContext variableInitializerList() { - return getRuleContext(VariableInitializerListContext.class, 0); - } - - public ArrayInitializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_arrayInitializer; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitArrayInitializer(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ArrayInitializerContext arrayInitializer() throws RecognitionException { - ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState()); - enterRule(_localctx, 248, RULE_arrayInitializer); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1471); - match(LBRACE); - setState(1473); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN) | (1L << LBRACE))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 6 [...] - { - setState(1472); - variableInitializerList(); - } - } - - setState(1476); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(1475); - match(COMMA); - } - } - - setState(1478); - match(RBRACE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class VariableInitializerListContext extends ParserRuleContext { - public List<? extends VariableInitializerContext> variableInitializer() { - return getRuleContexts(VariableInitializerContext.class); - } - - public VariableInitializerContext variableInitializer(int i) { - return getRuleContext(VariableInitializerContext.class, i); - } - - public VariableInitializerListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_variableInitializerList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitVariableInitializerList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final VariableInitializerListContext variableInitializerList() throws RecognitionException { - VariableInitializerListContext _localctx = new VariableInitializerListContext(_ctx, getState()); - enterRule(_localctx, 250, RULE_variableInitializerList); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1480); - variableInitializer(); - setState(1485); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 152, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1481); - match(COMMA); - setState(1482); - variableInitializer(); - } - } - } - setState(1487); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 152, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class BlockContext extends ParserRuleContext { - public BlockStatementsContext blockStatements() { - return getRuleContext(BlockStatementsContext.class, 0); - } - - public BlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_block; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) return ((Java8Visitor<? extends Result>) visitor).visitBlock(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final BlockContext block() throws RecognitionException { - BlockContext _localctx = new BlockContext(_ctx, getState()); - enterRule(_localctx, 252, RULE_block); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1488); - match(LBRACE); - setState(1490); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SW [...] - { - setState(1489); - blockStatements(); - } - } - - setState(1492); - match(RBRACE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class BlockStatementsContext extends ParserRuleContext { - public List<? extends BlockStatementContext> blockStatement() { - return getRuleContexts(BlockStatementContext.class); - } - - public BlockStatementContext blockStatement(int i) { - return getRuleContext(BlockStatementContext.class, i); - } - - public BlockStatementsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_blockStatements; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitBlockStatements(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final BlockStatementsContext blockStatements() throws RecognitionException { - BlockStatementsContext _localctx = new BlockStatementsContext(_ctx, getState()); - enterRule(_localctx, 254, RULE_blockStatements); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1494); - blockStatement(); - setState(1498); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << [...] - { - { - setState(1495); - blockStatement(); - } - } - setState(1500); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class BlockStatementContext extends ParserRuleContext { - public LocalVariableDeclarationStatementContext localVariableDeclarationStatement() { - return getRuleContext(LocalVariableDeclarationStatementContext.class, 0); - } - - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class, 0); - } - - public StatementContext statement() { - return getRuleContext(StatementContext.class, 0); - } - - public BlockStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_blockStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitBlockStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final BlockStatementContext blockStatement() throws RecognitionException { - BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState()); - enterRule(_localctx, 256, RULE_blockStatement); - try { - setState(1504); - switch (getInterpreter().adaptivePredict(_input, 155, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1501); - localVariableDeclarationStatement(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1502); - classDeclaration(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1503); - statement(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class LocalVariableDeclarationStatementContext extends ParserRuleContext { - public LocalVariableDeclarationContext localVariableDeclaration() { - return getRuleContext(LocalVariableDeclarationContext.class, 0); - } - - public LocalVariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_localVariableDeclarationStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitLocalVariableDeclarationStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final LocalVariableDeclarationStatementContext localVariableDeclarationStatement() throws RecognitionException { - LocalVariableDeclarationStatementContext _localctx = new LocalVariableDeclarationStatementContext(_ctx, getState()); - enterRule(_localctx, 258, RULE_localVariableDeclarationStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1506); - localVariableDeclaration(); - setState(1507); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class LocalVariableDeclarationContext extends ParserRuleContext { - public UnannTypeContext unannType() { - return getRuleContext(UnannTypeContext.class, 0); - } - - public VariableDeclaratorListContext variableDeclaratorList() { - return getRuleContext(VariableDeclaratorListContext.class, 0); - } - - public List<? extends VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_localVariableDeclaration; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitLocalVariableDeclaration(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException { - LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState()); - enterRule(_localctx, 260, RULE_localVariableDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1512); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == FINAL || _la == AT) { - { - { - setState(1509); - variableModifier(); - } - } - setState(1514); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1515); - unannType(); - setState(1516); - variableDeclaratorList(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class StatementContext extends ParserRuleContext { - public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() { - return getRuleContext(StatementWithoutTrailingSubstatementContext.class, 0); - } - - public LabeledStatementContext labeledStatement() { - return getRuleContext(LabeledStatementContext.class, 0); - } - - public IfThenStatementContext ifThenStatement() { - return getRuleContext(IfThenStatementContext.class, 0); - } - - public IfThenElseStatementContext ifThenElseStatement() { - return getRuleContext(IfThenElseStatementContext.class, 0); - } - - public WhileStatementContext whileStatement() { - return getRuleContext(WhileStatementContext.class, 0); - } - - public ForStatementContext forStatement() { - return getRuleContext(ForStatementContext.class, 0); - } - - public StatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_statement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final StatementContext statement() throws RecognitionException { - StatementContext _localctx = new StatementContext(_ctx, getState()); - enterRule(_localctx, 262, RULE_statement); - try { - setState(1524); - switch (getInterpreter().adaptivePredict(_input, 157, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1518); - statementWithoutTrailingSubstatement(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1519); - labeledStatement(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1520); - ifThenStatement(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1521); - ifThenElseStatement(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1522); - whileStatement(); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1523); - forStatement(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class StatementNoShortIfContext extends ParserRuleContext { - public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() { - return getRuleContext(StatementWithoutTrailingSubstatementContext.class, 0); - } - - public LabeledStatementNoShortIfContext labeledStatementNoShortIf() { - return getRuleContext(LabeledStatementNoShortIfContext.class, 0); - } - - public IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() { - return getRuleContext(IfThenElseStatementNoShortIfContext.class, 0); - } - - public WhileStatementNoShortIfContext whileStatementNoShortIf() { - return getRuleContext(WhileStatementNoShortIfContext.class, 0); - } - - public ForStatementNoShortIfContext forStatementNoShortIf() { - return getRuleContext(ForStatementNoShortIfContext.class, 0); - } - - public StatementNoShortIfContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_statementNoShortIf; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitStatementNoShortIf(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final StatementNoShortIfContext statementNoShortIf() throws RecognitionException { - StatementNoShortIfContext _localctx = new StatementNoShortIfContext(_ctx, getState()); - enterRule(_localctx, 264, RULE_statementNoShortIf); - try { - setState(1531); - switch (getInterpreter().adaptivePredict(_input, 158, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1526); - statementWithoutTrailingSubstatement(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1527); - labeledStatementNoShortIf(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1528); - ifThenElseStatementNoShortIf(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1529); - whileStatementNoShortIf(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1530); - forStatementNoShortIf(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class StatementWithoutTrailingSubstatementContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public EmptyStatementContext emptyStatement() { - return getRuleContext(EmptyStatementContext.class, 0); - } - - public ExpressionStatementContext expressionStatement() { - return getRuleContext(ExpressionStatementContext.class, 0); - } - - public AssertStatementContext assertStatement() { - return getRuleContext(AssertStatementContext.class, 0); - } - - public SwitchStatementContext switchStatement() { - return getRuleContext(SwitchStatementContext.class, 0); - } - - public DoStatementContext doStatement() { - return getRuleContext(DoStatementContext.class, 0); - } - - public BreakStatementContext breakStatement() { - return getRuleContext(BreakStatementContext.class, 0); - } - - public ContinueStatementContext continueStatement() { - return getRuleContext(ContinueStatementContext.class, 0); - } - - public ReturnStatementContext returnStatement() { - return getRuleContext(ReturnStatementContext.class, 0); - } - - public SynchronizedStatementContext synchronizedStatement() { - return getRuleContext(SynchronizedStatementContext.class, 0); - } - - public ThrowStatementContext throwStatement() { - return getRuleContext(ThrowStatementContext.class, 0); - } - - public TryStatementContext tryStatement() { - return getRuleContext(TryStatementContext.class, 0); - } - - public StatementWithoutTrailingSubstatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_statementWithoutTrailingSubstatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitStatementWithoutTrailingSubstatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() throws RecognitionException { - StatementWithoutTrailingSubstatementContext _localctx = new StatementWithoutTrailingSubstatementContext(_ctx, getState()); - enterRule(_localctx, 266, RULE_statementWithoutTrailingSubstatement); - try { - setState(1545); - switch (_input.LA(1)) { - case LBRACE: - enterOuterAlt(_localctx, 1); - { - setState(1533); - block(); - } - break; - case SEMI: - enterOuterAlt(_localctx, 2); - { - setState(1534); - emptyStatement(); - } - break; - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case NEW: - case SHORT: - case SUPER: - case THIS: - case VOID: - case IntegerLiteral: - case FloatingPointLiteral: - case BooleanLiteral: - case CharacterLiteral: - case StringLiteral: - case NullLiteral: - case LPAREN: - case INC: - case DEC: - case Identifier: - case AT: - enterOuterAlt(_localctx, 3); - { - setState(1535); - expressionStatement(); - } - break; - case ASSERT: - enterOuterAlt(_localctx, 4); - { - setState(1536); - assertStatement(); - } - break; - case SWITCH: - enterOuterAlt(_localctx, 5); - { - setState(1537); - switchStatement(); - } - break; - case DO: - enterOuterAlt(_localctx, 6); - { - setState(1538); - doStatement(); - } - break; - case BREAK: - enterOuterAlt(_localctx, 7); - { - setState(1539); - breakStatement(); - } - break; - case CONTINUE: - enterOuterAlt(_localctx, 8); - { - setState(1540); - continueStatement(); - } - break; - case RETURN: - enterOuterAlt(_localctx, 9); - { - setState(1541); - returnStatement(); - } - break; - case SYNCHRONIZED: - enterOuterAlt(_localctx, 10); - { - setState(1542); - synchronizedStatement(); - } - break; - case THROW: - enterOuterAlt(_localctx, 11); - { - setState(1543); - throwStatement(); - } - break; - case TRY: - enterOuterAlt(_localctx, 12); - { - setState(1544); - tryStatement(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class EmptyStatementContext extends ParserRuleContext { - public EmptyStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_emptyStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitEmptyStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final EmptyStatementContext emptyStatement() throws RecognitionException { - EmptyStatementContext _localctx = new EmptyStatementContext(_ctx, getState()); - enterRule(_localctx, 268, RULE_emptyStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1547); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class LabeledStatementContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public StatementContext statement() { - return getRuleContext(StatementContext.class, 0); - } - - public LabeledStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_labeledStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitLabeledStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final LabeledStatementContext labeledStatement() throws RecognitionException { - LabeledStatementContext _localctx = new LabeledStatementContext(_ctx, getState()); - enterRule(_localctx, 270, RULE_labeledStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1549); - match(Identifier); - setState(1550); - match(COLON); - setState(1551); - statement(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class LabeledStatementNoShortIfContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public StatementNoShortIfContext statementNoShortIf() { - return getRuleContext(StatementNoShortIfContext.class, 0); - } - - public LabeledStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_labeledStatementNoShortIf; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitLabeledStatementNoShortIf(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final LabeledStatementNoShortIfContext labeledStatementNoShortIf() throws RecognitionException { - LabeledStatementNoShortIfContext _localctx = new LabeledStatementNoShortIfContext(_ctx, getState()); - enterRule(_localctx, 272, RULE_labeledStatementNoShortIf); - try { - enterOuterAlt(_localctx, 1); - { - setState(1553); - match(Identifier); - setState(1554); - match(COLON); - setState(1555); - statementNoShortIf(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ExpressionStatementContext extends ParserRuleContext { - public StatementExpressionContext statementExpression() { - return getRuleContext(StatementExpressionContext.class, 0); - } - - public ExpressionStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_expressionStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitExpressionStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ExpressionStatementContext expressionStatement() throws RecognitionException { - ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState()); - enterRule(_localctx, 274, RULE_expressionStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1557); - statementExpression(); - setState(1558); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class StatementExpressionContext extends ParserRuleContext { - public AssignmentContext assignment() { - return getRuleContext(AssignmentContext.class, 0); - } - - public PreIncrementExpressionContext preIncrementExpression() { - return getRuleContext(PreIncrementExpressionContext.class, 0); - } - - public PreDecrementExpressionContext preDecrementExpression() { - return getRuleContext(PreDecrementExpressionContext.class, 0); - } - - public PostIncrementExpressionContext postIncrementExpression() { - return getRuleContext(PostIncrementExpressionContext.class, 0); - } - - public PostDecrementExpressionContext postDecrementExpression() { - return getRuleContext(PostDecrementExpressionContext.class, 0); - } - - public MethodInvocationContext methodInvocation() { - return getRuleContext(MethodInvocationContext.class, 0); - } - - public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { - return getRuleContext(ClassInstanceCreationExpressionContext.class, 0); - } - - public StatementExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_statementExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitStatementExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final StatementExpressionContext statementExpression() throws RecognitionException { - StatementExpressionContext _localctx = new StatementExpressionContext(_ctx, getState()); - enterRule(_localctx, 276, RULE_statementExpression); - try { - setState(1567); - switch (getInterpreter().adaptivePredict(_input, 160, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1560); - assignment(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1561); - preIncrementExpression(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1562); - preDecrementExpression(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1563); - postIncrementExpression(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1564); - postDecrementExpression(); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1565); - methodInvocation(); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(1566); - classInstanceCreationExpression(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class IfThenStatementContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public StatementContext statement() { - return getRuleContext(StatementContext.class, 0); - } - - public IfThenStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_ifThenStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitIfThenStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final IfThenStatementContext ifThenStatement() throws RecognitionException { - IfThenStatementContext _localctx = new IfThenStatementContext(_ctx, getState()); - enterRule(_localctx, 278, RULE_ifThenStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1569); - match(IF); - setState(1570); - match(LPAREN); - setState(1571); - expression(); - setState(1572); - match(RPAREN); - setState(1573); - statement(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class IfThenElseStatementContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public StatementNoShortIfContext statementNoShortIf() { - return getRuleContext(StatementNoShortIfContext.class, 0); - } - - public StatementContext statement() { - return getRuleContext(StatementContext.class, 0); - } - - public IfThenElseStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_ifThenElseStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitIfThenElseStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final IfThenElseStatementContext ifThenElseStatement() throws RecognitionException { - IfThenElseStatementContext _localctx = new IfThenElseStatementContext(_ctx, getState()); - enterRule(_localctx, 280, RULE_ifThenElseStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1575); - match(IF); - setState(1576); - match(LPAREN); - setState(1577); - expression(); - setState(1578); - match(RPAREN); - setState(1579); - statementNoShortIf(); - setState(1580); - match(ELSE); - setState(1581); - statement(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class IfThenElseStatementNoShortIfContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public List<? extends StatementNoShortIfContext> statementNoShortIf() { - return getRuleContexts(StatementNoShortIfContext.class); - } - - public StatementNoShortIfContext statementNoShortIf(int i) { - return getRuleContext(StatementNoShortIfContext.class, i); - } - - public IfThenElseStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_ifThenElseStatementNoShortIf; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitIfThenElseStatementNoShortIf(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() throws RecognitionException { - IfThenElseStatementNoShortIfContext _localctx = new IfThenElseStatementNoShortIfContext(_ctx, getState()); - enterRule(_localctx, 282, RULE_ifThenElseStatementNoShortIf); - try { - enterOuterAlt(_localctx, 1); - { - setState(1583); - match(IF); - setState(1584); - match(LPAREN); - setState(1585); - expression(); - setState(1586); - match(RPAREN); - setState(1587); - statementNoShortIf(); - setState(1588); - match(ELSE); - setState(1589); - statementNoShortIf(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AssertStatementContext extends ParserRuleContext { - public List<? extends ExpressionContext> expression() { - return getRuleContexts(ExpressionContext.class); - } - - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class, i); - } - - public AssertStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_assertStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAssertStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AssertStatementContext assertStatement() throws RecognitionException { - AssertStatementContext _localctx = new AssertStatementContext(_ctx, getState()); - enterRule(_localctx, 284, RULE_assertStatement); - try { - setState(1601); - switch (getInterpreter().adaptivePredict(_input, 161, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1591); - match(ASSERT); - setState(1592); - expression(); - setState(1593); - match(SEMI); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1595); - match(ASSERT); - setState(1596); - expression(); - setState(1597); - match(COLON); - setState(1598); - expression(); - setState(1599); - match(SEMI); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SwitchStatementContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public SwitchBlockContext switchBlock() { - return getRuleContext(SwitchBlockContext.class, 0); - } - - public SwitchStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_switchStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSwitchStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SwitchStatementContext switchStatement() throws RecognitionException { - SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState()); - enterRule(_localctx, 286, RULE_switchStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1603); - match(SWITCH); - setState(1604); - match(LPAREN); - setState(1605); - expression(); - setState(1606); - match(RPAREN); - setState(1607); - switchBlock(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SwitchBlockContext extends ParserRuleContext { - public List<? extends SwitchBlockStatementGroupContext> switchBlockStatementGroup() { - return getRuleContexts(SwitchBlockStatementGroupContext.class); - } - - public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) { - return getRuleContext(SwitchBlockStatementGroupContext.class, i); - } - - public List<? extends SwitchLabelContext> switchLabel() { - return getRuleContexts(SwitchLabelContext.class); - } - - public SwitchLabelContext switchLabel(int i) { - return getRuleContext(SwitchLabelContext.class, i); - } - - public SwitchBlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_switchBlock; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSwitchBlock(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SwitchBlockContext switchBlock() throws RecognitionException { - SwitchBlockContext _localctx = new SwitchBlockContext(_ctx, getState()); - enterRule(_localctx, 288, RULE_switchBlock); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1609); - match(LBRACE); - setState(1613); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 162, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1610); - switchBlockStatementGroup(); - } - } - } - setState(1615); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 162, _ctx); - } - setState(1619); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == CASE || _la == DEFAULT) { - { - { - setState(1616); - switchLabel(); - } - } - setState(1621); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1622); - match(RBRACE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SwitchBlockStatementGroupContext extends ParserRuleContext { - public SwitchLabelsContext switchLabels() { - return getRuleContext(SwitchLabelsContext.class, 0); - } - - public BlockStatementsContext blockStatements() { - return getRuleContext(BlockStatementsContext.class, 0); - } - - public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_switchBlockStatementGroup; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSwitchBlockStatementGroup(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException { - SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState()); - enterRule(_localctx, 290, RULE_switchBlockStatementGroup); - try { - enterOuterAlt(_localctx, 1); - { - setState(1624); - switchLabels(); - setState(1625); - blockStatements(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SwitchLabelsContext extends ParserRuleContext { - public List<? extends SwitchLabelContext> switchLabel() { - return getRuleContexts(SwitchLabelContext.class); - } - - public SwitchLabelContext switchLabel(int i) { - return getRuleContext(SwitchLabelContext.class, i); - } - - public SwitchLabelsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_switchLabels; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSwitchLabels(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SwitchLabelsContext switchLabels() throws RecognitionException { - SwitchLabelsContext _localctx = new SwitchLabelsContext(_ctx, getState()); - enterRule(_localctx, 292, RULE_switchLabels); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1627); - switchLabel(); - setState(1631); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == CASE || _la == DEFAULT) { - { - { - setState(1628); - switchLabel(); - } - } - setState(1633); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SwitchLabelContext extends ParserRuleContext { - public ConstantExpressionContext constantExpression() { - return getRuleContext(ConstantExpressionContext.class, 0); - } - - public EnumConstantNameContext enumConstantName() { - return getRuleContext(EnumConstantNameContext.class, 0); - } - - public SwitchLabelContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_switchLabel; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSwitchLabel(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SwitchLabelContext switchLabel() throws RecognitionException { - SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState()); - enterRule(_localctx, 294, RULE_switchLabel); - try { - setState(1644); - switch (getInterpreter().adaptivePredict(_input, 165, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1634); - match(CASE); - setState(1635); - constantExpression(); - setState(1636); - match(COLON); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1638); - match(CASE); - setState(1639); - enumConstantName(); - setState(1640); - match(COLON); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1642); - match(DEFAULT); - setState(1643); - match(COLON); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class EnumConstantNameContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public EnumConstantNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enumConstantName; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitEnumConstantName(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final EnumConstantNameContext enumConstantName() throws RecognitionException { - EnumConstantNameContext _localctx = new EnumConstantNameContext(_ctx, getState()); - enterRule(_localctx, 296, RULE_enumConstantName); - try { - enterOuterAlt(_localctx, 1); - { - setState(1646); - match(Identifier); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class WhileStatementContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public StatementContext statement() { - return getRuleContext(StatementContext.class, 0); - } - - public WhileStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_whileStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitWhileStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final WhileStatementContext whileStatement() throws RecognitionException { - WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState()); - enterRule(_localctx, 298, RULE_whileStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1648); - match(WHILE); - setState(1649); - match(LPAREN); - setState(1650); - expression(); - setState(1651); - match(RPAREN); - setState(1652); - statement(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class WhileStatementNoShortIfContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public StatementNoShortIfContext statementNoShortIf() { - return getRuleContext(StatementNoShortIfContext.class, 0); - } - - public WhileStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_whileStatementNoShortIf; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitWhileStatementNoShortIf(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final WhileStatementNoShortIfContext whileStatementNoShortIf() throws RecognitionException { - WhileStatementNoShortIfContext _localctx = new WhileStatementNoShortIfContext(_ctx, getState()); - enterRule(_localctx, 300, RULE_whileStatementNoShortIf); - try { - enterOuterAlt(_localctx, 1); - { - setState(1654); - match(WHILE); - setState(1655); - match(LPAREN); - setState(1656); - expression(); - setState(1657); - match(RPAREN); - setState(1658); - statementNoShortIf(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class DoStatementContext extends ParserRuleContext { - public StatementContext statement() { - return getRuleContext(StatementContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public DoStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_doStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitDoStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final DoStatementContext doStatement() throws RecognitionException { - DoStatementContext _localctx = new DoStatementContext(_ctx, getState()); - enterRule(_localctx, 302, RULE_doStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1660); - match(DO); - setState(1661); - statement(); - setState(1662); - match(WHILE); - setState(1663); - match(LPAREN); - setState(1664); - expression(); - setState(1665); - match(RPAREN); - setState(1666); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ForStatementContext extends ParserRuleContext { - public BasicForStatementContext basicForStatement() { - return getRuleContext(BasicForStatementContext.class, 0); - } - - public EnhancedForStatementContext enhancedForStatement() { - return getRuleContext(EnhancedForStatementContext.class, 0); - } - - public ForStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_forStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitForStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ForStatementContext forStatement() throws RecognitionException { - ForStatementContext _localctx = new ForStatementContext(_ctx, getState()); - enterRule(_localctx, 304, RULE_forStatement); - try { - setState(1670); - switch (getInterpreter().adaptivePredict(_input, 166, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1668); - basicForStatement(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1669); - enhancedForStatement(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ForStatementNoShortIfContext extends ParserRuleContext { - public BasicForStatementNoShortIfContext basicForStatementNoShortIf() { - return getRuleContext(BasicForStatementNoShortIfContext.class, 0); - } - - public EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() { - return getRuleContext(EnhancedForStatementNoShortIfContext.class, 0); - } - - public ForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_forStatementNoShortIf; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitForStatementNoShortIf(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ForStatementNoShortIfContext forStatementNoShortIf() throws RecognitionException { - ForStatementNoShortIfContext _localctx = new ForStatementNoShortIfContext(_ctx, getState()); - enterRule(_localctx, 306, RULE_forStatementNoShortIf); - try { - setState(1674); - switch (getInterpreter().adaptivePredict(_input, 167, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1672); - basicForStatementNoShortIf(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1673); - enhancedForStatementNoShortIf(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class BasicForStatementContext extends ParserRuleContext { - public StatementContext statement() { - return getRuleContext(StatementContext.class, 0); - } - - public ForInitContext forInit() { - return getRuleContext(ForInitContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ForUpdateContext forUpdate() { - return getRuleContext(ForUpdateContext.class, 0); - } - - public BasicForStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_basicForStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitBasicForStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final BasicForStatementContext basicForStatement() throws RecognitionException { - BasicForStatementContext _localctx = new BasicForStatementContext(_ctx, getState()); - enterRule(_localctx, 308, RULE_basicForStatement); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1676); - match(FOR); - setState(1677); - match(LPAREN); - setState(1679); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79 [...] - { - setState(1678); - forInit(); - } - } - - setState(1681); - match(SEMI); - setState(1683); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BA [...] - { - setState(1682); - expression(); - } - } - - setState(1685); - match(SEMI); - setState(1687); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << (IN [...] - { - setState(1686); - forUpdate(); - } - } - - setState(1689); - match(RPAREN); - setState(1690); - statement(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class BasicForStatementNoShortIfContext extends ParserRuleContext { - public StatementNoShortIfContext statementNoShortIf() { - return getRuleContext(StatementNoShortIfContext.class, 0); - } - - public ForInitContext forInit() { - return getRuleContext(ForInitContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ForUpdateContext forUpdate() { - return getRuleContext(ForUpdateContext.class, 0); - } - - public BasicForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_basicForStatementNoShortIf; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitBasicForStatementNoShortIf(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final BasicForStatementNoShortIfContext basicForStatementNoShortIf() throws RecognitionException { - BasicForStatementNoShortIfContext _localctx = new BasicForStatementNoShortIfContext(_ctx, getState()); - enterRule(_localctx, 310, RULE_basicForStatementNoShortIf); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1692); - match(FOR); - setState(1693); - match(LPAREN); - setState(1695); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79 [...] - { - setState(1694); - forInit(); - } - } - - setState(1697); - match(SEMI); - setState(1699); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BA [...] - { - setState(1698); - expression(); - } - } - - setState(1701); - match(SEMI); - setState(1703); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << (IN [...] - { - setState(1702); - forUpdate(); - } - } - - setState(1705); - match(RPAREN); - setState(1706); - statementNoShortIf(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ForInitContext extends ParserRuleContext { - public StatementExpressionListContext statementExpressionList() { - return getRuleContext(StatementExpressionListContext.class, 0); - } - - public LocalVariableDeclarationContext localVariableDeclaration() { - return getRuleContext(LocalVariableDeclarationContext.class, 0); - } - - public ForInitContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_forInit; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitForInit(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ForInitContext forInit() throws RecognitionException { - ForInitContext _localctx = new ForInitContext(_ctx, getState()); - enterRule(_localctx, 312, RULE_forInit); - try { - setState(1710); - switch (getInterpreter().adaptivePredict(_input, 174, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1708); - statementExpressionList(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1709); - localVariableDeclaration(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ForUpdateContext extends ParserRuleContext { - public StatementExpressionListContext statementExpressionList() { - return getRuleContext(StatementExpressionListContext.class, 0); - } - - public ForUpdateContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_forUpdate; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitForUpdate(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ForUpdateContext forUpdate() throws RecognitionException { - ForUpdateContext _localctx = new ForUpdateContext(_ctx, getState()); - enterRule(_localctx, 314, RULE_forUpdate); - try { - enterOuterAlt(_localctx, 1); - { - setState(1712); - statementExpressionList(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class StatementExpressionListContext extends ParserRuleContext { - public List<? extends StatementExpressionContext> statementExpression() { - return getRuleContexts(StatementExpressionContext.class); - } - - public StatementExpressionContext statementExpression(int i) { - return getRuleContext(StatementExpressionContext.class, i); - } - - public StatementExpressionListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_statementExpressionList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitStatementExpressionList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final StatementExpressionListContext statementExpressionList() throws RecognitionException { - StatementExpressionListContext _localctx = new StatementExpressionListContext(_ctx, getState()); - enterRule(_localctx, 316, RULE_statementExpressionList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1714); - statementExpression(); - setState(1719); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(1715); - match(COMMA); - setState(1716); - statementExpression(); - } - } - setState(1721); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class EnhancedForStatementContext extends ParserRuleContext { - public UnannTypeContext unannType() { - return getRuleContext(UnannTypeContext.class, 0); - } - - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public StatementContext statement() { - return getRuleContext(StatementContext.class, 0); - } - - public List<? extends VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public EnhancedForStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enhancedForStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitEnhancedForStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final EnhancedForStatementContext enhancedForStatement() throws RecognitionException { - EnhancedForStatementContext _localctx = new EnhancedForStatementContext(_ctx, getState()); - enterRule(_localctx, 318, RULE_enhancedForStatement); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1722); - match(FOR); - setState(1723); - match(LPAREN); - setState(1727); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == FINAL || _la == AT) { - { - { - setState(1724); - variableModifier(); - } - } - setState(1729); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1730); - unannType(); - setState(1731); - variableDeclaratorId(); - setState(1732); - match(COLON); - setState(1733); - expression(); - setState(1734); - match(RPAREN); - setState(1735); - statement(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class EnhancedForStatementNoShortIfContext extends ParserRuleContext { - public UnannTypeContext unannType() { - return getRuleContext(UnannTypeContext.class, 0); - } - - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public StatementNoShortIfContext statementNoShortIf() { - return getRuleContext(StatementNoShortIfContext.class, 0); - } - - public List<? extends VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public EnhancedForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enhancedForStatementNoShortIf; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitEnhancedForStatementNoShortIf(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() throws RecognitionException { - EnhancedForStatementNoShortIfContext _localctx = new EnhancedForStatementNoShortIfContext(_ctx, getState()); - enterRule(_localctx, 320, RULE_enhancedForStatementNoShortIf); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1737); - match(FOR); - setState(1738); - match(LPAREN); - setState(1742); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == FINAL || _la == AT) { - { - { - setState(1739); - variableModifier(); - } - } - setState(1744); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1745); - unannType(); - setState(1746); - variableDeclaratorId(); - setState(1747); - match(COLON); - setState(1748); - expression(); - setState(1749); - match(RPAREN); - setState(1750); - statementNoShortIf(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class BreakStatementContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public BreakStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_breakStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitBreakStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final BreakStatementContext breakStatement() throws RecognitionException { - BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState()); - enterRule(_localctx, 322, RULE_breakStatement); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1752); - match(BREAK); - setState(1754); - _la = _input.LA(1); - if (_la == Identifier) { - { - setState(1753); - match(Identifier); - } - } - - setState(1756); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ContinueStatementContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public ContinueStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_continueStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitContinueStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ContinueStatementContext continueStatement() throws RecognitionException { - ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState()); - enterRule(_localctx, 324, RULE_continueStatement); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1758); - match(CONTINUE); - setState(1760); - _la = _input.LA(1); - if (_la == Identifier) { - { - setState(1759); - match(Identifier); - } - } - - setState(1762); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ReturnStatementContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ReturnStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_returnStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitReturnStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ReturnStatementContext returnStatement() throws RecognitionException { - ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState()); - enterRule(_localctx, 326, RULE_returnStatement); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1764); - match(RETURN); - setState(1766); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BA [...] - { - setState(1765); - expression(); - } - } - - setState(1768); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ThrowStatementContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ThrowStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_throwStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitThrowStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ThrowStatementContext throwStatement() throws RecognitionException { - ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState()); - enterRule(_localctx, 328, RULE_throwStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1770); - match(THROW); - setState(1771); - expression(); - setState(1772); - match(SEMI); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SynchronizedStatementContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public SynchronizedStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_synchronizedStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitSynchronizedStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final SynchronizedStatementContext synchronizedStatement() throws RecognitionException { - SynchronizedStatementContext _localctx = new SynchronizedStatementContext(_ctx, getState()); - enterRule(_localctx, 330, RULE_synchronizedStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1774); - match(SYNCHRONIZED); - setState(1775); - match(LPAREN); - setState(1776); - expression(); - setState(1777); - match(RPAREN); - setState(1778); - block(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TryStatementContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public CatchesContext catches() { - return getRuleContext(CatchesContext.class, 0); - } - - public Finally_Context finally_() { - return getRuleContext(Finally_Context.class, 0); - } - - public TryWithResourcesStatementContext tryWithResourcesStatement() { - return getRuleContext(TryWithResourcesStatementContext.class, 0); - } - - public TryStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_tryStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTryStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TryStatementContext tryStatement() throws RecognitionException { - TryStatementContext _localctx = new TryStatementContext(_ctx, getState()); - enterRule(_localctx, 332, RULE_tryStatement); - int _la; - try { - setState(1792); - switch (getInterpreter().adaptivePredict(_input, 182, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1780); - match(TRY); - setState(1781); - block(); - setState(1782); - catches(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1784); - match(TRY); - setState(1785); - block(); - setState(1787); - _la = _input.LA(1); - if (_la == CATCH) { - { - setState(1786); - catches(); - } - } - - setState(1789); - finally_(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1791); - tryWithResourcesStatement(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class CatchesContext extends ParserRuleContext { - public List<? extends CatchClauseContext> catchClause() { - return getRuleContexts(CatchClauseContext.class); - } - - public CatchClauseContext catchClause(int i) { - return getRuleContext(CatchClauseContext.class, i); - } - - public CatchesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_catches; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitCatches(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final CatchesContext catches() throws RecognitionException { - CatchesContext _localctx = new CatchesContext(_ctx, getState()); - enterRule(_localctx, 334, RULE_catches); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1794); - catchClause(); - setState(1798); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == CATCH) { - { - { - setState(1795); - catchClause(); - } - } - setState(1800); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class CatchClauseContext extends ParserRuleContext { - public CatchFormalParameterContext catchFormalParameter() { - return getRuleContext(CatchFormalParameterContext.class, 0); - } - - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public CatchClauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_catchClause; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitCatchClause(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final CatchClauseContext catchClause() throws RecognitionException { - CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState()); - enterRule(_localctx, 336, RULE_catchClause); - try { - enterOuterAlt(_localctx, 1); - { - setState(1801); - match(CATCH); - setState(1802); - match(LPAREN); - setState(1803); - catchFormalParameter(); - setState(1804); - match(RPAREN); - setState(1805); - block(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class CatchFormalParameterContext extends ParserRuleContext { - public CatchTypeContext catchType() { - return getRuleContext(CatchTypeContext.class, 0); - } - - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public List<? extends VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public CatchFormalParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_catchFormalParameter; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitCatchFormalParameter(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final CatchFormalParameterContext catchFormalParameter() throws RecognitionException { - CatchFormalParameterContext _localctx = new CatchFormalParameterContext(_ctx, getState()); - enterRule(_localctx, 338, RULE_catchFormalParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1810); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == FINAL || _la == AT) { - { - { - setState(1807); - variableModifier(); - } - } - setState(1812); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1813); - catchType(); - setState(1814); - variableDeclaratorId(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class CatchTypeContext extends ParserRuleContext { - public UnannClassTypeContext unannClassType() { - return getRuleContext(UnannClassTypeContext.class, 0); - } - - public List<? extends ClassTypeContext> classType() { - return getRuleContexts(ClassTypeContext.class); - } - - public ClassTypeContext classType(int i) { - return getRuleContext(ClassTypeContext.class, i); - } - - public CatchTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_catchType; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitCatchType(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final CatchTypeContext catchType() throws RecognitionException { - CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState()); - enterRule(_localctx, 340, RULE_catchType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1816); - unannClassType(); - setState(1821); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == BITOR) { - { - { - setState(1817); - match(BITOR); - setState(1818); - classType(); - } - } - setState(1823); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Finally_Context extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public Finally_Context(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_finally_; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitFinally_(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final Finally_Context finally_() throws RecognitionException { - Finally_Context _localctx = new Finally_Context(_ctx, getState()); - enterRule(_localctx, 342, RULE_finally_); - try { - enterOuterAlt(_localctx, 1); - { - setState(1824); - match(FINALLY); - setState(1825); - block(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TryWithResourcesStatementContext extends ParserRuleContext { - public ResourceSpecificationContext resourceSpecification() { - return getRuleContext(ResourceSpecificationContext.class, 0); - } - - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public CatchesContext catches() { - return getRuleContext(CatchesContext.class, 0); - } - - public Finally_Context finally_() { - return getRuleContext(Finally_Context.class, 0); - } - - public TryWithResourcesStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_tryWithResourcesStatement; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTryWithResourcesStatement(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TryWithResourcesStatementContext tryWithResourcesStatement() throws RecognitionException { - TryWithResourcesStatementContext _localctx = new TryWithResourcesStatementContext(_ctx, getState()); - enterRule(_localctx, 344, RULE_tryWithResourcesStatement); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1827); - match(TRY); - setState(1828); - resourceSpecification(); - setState(1829); - block(); - setState(1831); - _la = _input.LA(1); - if (_la == CATCH) { - { - setState(1830); - catches(); - } - } - - setState(1834); - _la = _input.LA(1); - if (_la == FINALLY) { - { - setState(1833); - finally_(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ResourceSpecificationContext extends ParserRuleContext { - public ResourceListContext resourceList() { - return getRuleContext(ResourceListContext.class, 0); - } - - public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_resourceSpecification; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitResourceSpecification(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ResourceSpecificationContext resourceSpecification() throws RecognitionException { - ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState()); - enterRule(_localctx, 346, RULE_resourceSpecification); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1836); - match(LPAREN); - setState(1837); - resourceList(); - setState(1839); - _la = _input.LA(1); - if (_la == SEMI) { - { - setState(1838); - match(SEMI); - } - } - - setState(1841); - match(RPAREN); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ResourceListContext extends ParserRuleContext { - public List<? extends ResourceContext> resource() { - return getRuleContexts(ResourceContext.class); - } - - public ResourceContext resource(int i) { - return getRuleContext(ResourceContext.class, i); - } - - public ResourceListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_resourceList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitResourceList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ResourceListContext resourceList() throws RecognitionException { - ResourceListContext _localctx = new ResourceListContext(_ctx, getState()); - enterRule(_localctx, 348, RULE_resourceList); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1843); - resource(); - setState(1848); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 189, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1844); - match(SEMI); - setState(1845); - resource(); - } - } - } - setState(1850); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 189, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ResourceContext extends ParserRuleContext { - public UnannTypeContext unannType() { - return getRuleContext(UnannTypeContext.class, 0); - } - - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public List<? extends VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public ResourceContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_resource; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitResource(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ResourceContext resource() throws RecognitionException { - ResourceContext _localctx = new ResourceContext(_ctx, getState()); - enterRule(_localctx, 350, RULE_resource); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1854); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == FINAL || _la == AT) { - { - { - setState(1851); - variableModifier(); - } - } - setState(1856); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1857); - unannType(); - setState(1858); - variableDeclaratorId(); - setState(1859); - match(ASSIGN); - setState(1860); - expression(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryContext extends ParserRuleContext { - public PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() { - return getRuleContext(PrimaryNoNewArray_lfno_primaryContext.class, 0); - } - - public ArrayCreationExpressionContext arrayCreationExpression() { - return getRuleContext(ArrayCreationExpressionContext.class, 0); - } - - public List<? extends PrimaryNoNewArray_lf_primaryContext> primaryNoNewArray_lf_primary() { - return getRuleContexts(PrimaryNoNewArray_lf_primaryContext.class); - } - - public PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary(int i) { - return getRuleContext(PrimaryNoNewArray_lf_primaryContext.class, i); - } - - public PrimaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPrimary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PrimaryContext primary() throws RecognitionException { - PrimaryContext _localctx = new PrimaryContext(_ctx, getState()); - enterRule(_localctx, 352, RULE_primary); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1864); - switch (getInterpreter().adaptivePredict(_input, 191, _ctx)) { - case 1: { - setState(1862); - primaryNoNewArray_lfno_primary(); - } - break; - case 2: { - setState(1863); - arrayCreationExpression(); - } - break; - } - setState(1869); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 192, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1866); - primaryNoNewArray_lf_primary(); - } - } - } - setState(1871); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 192, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryNoNewArrayContext extends ParserRuleContext { - public LiteralContext literal() { - return getRuleContext(LiteralContext.class, 0); - } - - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { - return getRuleContext(ClassInstanceCreationExpressionContext.class, 0); - } - - public FieldAccessContext fieldAccess() { - return getRuleContext(FieldAccessContext.class, 0); - } - - public ArrayAccessContext arrayAccess() { - return getRuleContext(ArrayAccessContext.class, 0); - } - - public MethodInvocationContext methodInvocation() { - return getRuleContext(MethodInvocationContext.class, 0); - } - - public MethodReferenceContext methodReference() { - return getRuleContext(MethodReferenceContext.class, 0); - } - - public PrimaryNoNewArrayContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_primaryNoNewArray; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPrimaryNoNewArray(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PrimaryNoNewArrayContext primaryNoNewArray() throws RecognitionException { - PrimaryNoNewArrayContext _localctx = new PrimaryNoNewArrayContext(_ctx, getState()); - enterRule(_localctx, 354, RULE_primaryNoNewArray); - int _la; - try { - setState(1901); - switch (getInterpreter().adaptivePredict(_input, 194, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1872); - literal(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1873); - typeName(); - setState(1878); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == LBRACK) { - { - { - setState(1874); - match(LBRACK); - setState(1875); - match(RBRACK); - } - } - setState(1880); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1881); - match(DOT); - setState(1882); - match(CLASS); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1884); - match(VOID); - setState(1885); - match(DOT); - setState(1886); - match(CLASS); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1887); - match(THIS); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1888); - typeName(); - setState(1889); - match(DOT); - setState(1890); - match(THIS); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1892); - match(LPAREN); - setState(1893); - expression(); - setState(1894); - match(RPAREN); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(1896); - classInstanceCreationExpression(); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(1897); - fieldAccess(); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(1898); - arrayAccess(); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(1899); - methodInvocation(); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(1900); - methodReference(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryNoNewArray_lf_arrayAccessContext extends ParserRuleContext { - public PrimaryNoNewArray_lf_arrayAccessContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_primaryNoNewArray_lf_arrayAccess; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPrimaryNoNewArray_lf_arrayAccess(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess() throws RecognitionException { - PrimaryNoNewArray_lf_arrayAccessContext _localctx = new PrimaryNoNewArray_lf_arrayAccessContext(_ctx, getState()); - enterRule(_localctx, 356, RULE_primaryNoNewArray_lf_arrayAccess); - try { - enterOuterAlt(_localctx, 1); - { - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryNoNewArray_lfno_arrayAccessContext extends ParserRuleContext { - public LiteralContext literal() { - return getRuleContext(LiteralContext.class, 0); - } - - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { - return getRuleContext(ClassInstanceCreationExpressionContext.class, 0); - } - - public FieldAccessContext fieldAccess() { - return getRuleContext(FieldAccessContext.class, 0); - } - - public MethodInvocationContext methodInvocation() { - return getRuleContext(MethodInvocationContext.class, 0); - } - - public MethodReferenceContext methodReference() { - return getRuleContext(MethodReferenceContext.class, 0); - } - - public PrimaryNoNewArray_lfno_arrayAccessContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_primaryNoNewArray_lfno_arrayAccess; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPrimaryNoNewArray_lfno_arrayAccess(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() throws RecognitionException { - PrimaryNoNewArray_lfno_arrayAccessContext _localctx = new PrimaryNoNewArray_lfno_arrayAccessContext(_ctx, getState()); - enterRule(_localctx, 358, RULE_primaryNoNewArray_lfno_arrayAccess); - int _la; - try { - setState(1933); - switch (getInterpreter().adaptivePredict(_input, 196, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1905); - literal(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1906); - typeName(); - setState(1911); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == LBRACK) { - { - { - setState(1907); - match(LBRACK); - setState(1908); - match(RBRACK); - } - } - setState(1913); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1914); - match(DOT); - setState(1915); - match(CLASS); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1917); - match(VOID); - setState(1918); - match(DOT); - setState(1919); - match(CLASS); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1920); - match(THIS); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1921); - typeName(); - setState(1922); - match(DOT); - setState(1923); - match(THIS); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1925); - match(LPAREN); - setState(1926); - expression(); - setState(1927); - match(RPAREN); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(1929); - classInstanceCreationExpression(); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(1930); - fieldAccess(); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(1931); - methodInvocation(); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(1932); - methodReference(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryNoNewArray_lf_primaryContext extends ParserRuleContext { - public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() { - return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class, 0); - } - - public FieldAccess_lf_primaryContext fieldAccess_lf_primary() { - return getRuleContext(FieldAccess_lf_primaryContext.class, 0); - } - - public ArrayAccess_lf_primaryContext arrayAccess_lf_primary() { - return getRuleContext(ArrayAccess_lf_primaryContext.class, 0); - } - - public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() { - return getRuleContext(MethodInvocation_lf_primaryContext.class, 0); - } - - public MethodReference_lf_primaryContext methodReference_lf_primary() { - return getRuleContext(MethodReference_lf_primaryContext.class, 0); - } - - public PrimaryNoNewArray_lf_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_primaryNoNewArray_lf_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPrimaryNoNewArray_lf_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary() throws RecognitionException { - PrimaryNoNewArray_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primaryContext(_ctx, getState()); - enterRule(_localctx, 360, RULE_primaryNoNewArray_lf_primary); - try { - setState(1940); - switch (getInterpreter().adaptivePredict(_input, 197, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1935); - classInstanceCreationExpression_lf_primary(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1936); - fieldAccess_lf_primary(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1937); - arrayAccess_lf_primary(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1938); - methodInvocation_lf_primary(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1939); - methodReference_lf_primary(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext extends ParserRuleContext { - public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() throws RecognitionException { - PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(_ctx, getState()); - enterRule(_localctx, 362, RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary); - try { - enterOuterAlt(_localctx, 1); - { - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext extends ParserRuleContext { - public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() { - return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class, 0); - } - - public FieldAccess_lf_primaryContext fieldAccess_lf_primary() { - return getRuleContext(FieldAccess_lf_primaryContext.class, 0); - } - - public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() { - return getRuleContext(MethodInvocation_lf_primaryContext.class, 0); - } - - public MethodReference_lf_primaryContext methodReference_lf_primary() { - return getRuleContext(MethodReference_lf_primaryContext.class, 0); - } - - public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() throws RecognitionException { - PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(_ctx, getState()); - enterRule(_localctx, 364, RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary); - try { - setState(1948); - switch (getInterpreter().adaptivePredict(_input, 198, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1944); - classInstanceCreationExpression_lf_primary(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1945); - fieldAccess_lf_primary(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1946); - methodInvocation_lf_primary(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1947); - methodReference_lf_primary(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryNoNewArray_lfno_primaryContext extends ParserRuleContext { - public LiteralContext literal() { - return getRuleContext(LiteralContext.class, 0); - } - - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public UnannPrimitiveTypeContext unannPrimitiveType() { - return getRuleContext(UnannPrimitiveTypeContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() { - return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class, 0); - } - - public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() { - return getRuleContext(FieldAccess_lfno_primaryContext.class, 0); - } - - public ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() { - return getRuleContext(ArrayAccess_lfno_primaryContext.class, 0); - } - - public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() { - return getRuleContext(MethodInvocation_lfno_primaryContext.class, 0); - } - - public MethodReference_lfno_primaryContext methodReference_lfno_primary() { - return getRuleContext(MethodReference_lfno_primaryContext.class, 0); - } - - public PrimaryNoNewArray_lfno_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_primaryNoNewArray_lfno_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPrimaryNoNewArray_lfno_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() throws RecognitionException { - PrimaryNoNewArray_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primaryContext(_ctx, getState()); - enterRule(_localctx, 366, RULE_primaryNoNewArray_lfno_primary); - int _la; - try { - setState(1990); - switch (getInterpreter().adaptivePredict(_input, 201, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1950); - literal(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1951); - typeName(); - setState(1956); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == LBRACK) { - { - { - setState(1952); - match(LBRACK); - setState(1953); - match(RBRACK); - } - } - setState(1958); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1959); - match(DOT); - setState(1960); - match(CLASS); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1962); - unannPrimitiveType(); - setState(1967); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == LBRACK) { - { - { - setState(1963); - match(LBRACK); - setState(1964); - match(RBRACK); - } - } - setState(1969); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1970); - match(DOT); - setState(1971); - match(CLASS); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1973); - match(VOID); - setState(1974); - match(DOT); - setState(1975); - match(CLASS); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1976); - match(THIS); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1977); - typeName(); - setState(1978); - match(DOT); - setState(1979); - match(THIS); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(1981); - match(LPAREN); - setState(1982); - expression(); - setState(1983); - match(RPAREN); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(1985); - classInstanceCreationExpression_lfno_primary(); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(1986); - fieldAccess_lfno_primary(); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(1987); - arrayAccess_lfno_primary(); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(1988); - methodInvocation_lfno_primary(); - } - break; - case 12: - enterOuterAlt(_localctx, 12); - { - setState(1989); - methodReference_lfno_primary(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext extends ParserRuleContext { - public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() throws RecognitionException { - PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(_ctx, getState()); - enterRule(_localctx, 368, RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary); - try { - enterOuterAlt(_localctx, 1); - { - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext extends ParserRuleContext { - public LiteralContext literal() { - return getRuleContext(LiteralContext.class, 0); - } - - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public UnannPrimitiveTypeContext unannPrimitiveType() { - return getRuleContext(UnannPrimitiveTypeContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() { - return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class, 0); - } - - public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() { - return getRuleContext(FieldAccess_lfno_primaryContext.class, 0); - } - - public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() { - return getRuleContext(MethodInvocation_lfno_primaryContext.class, 0); - } - - public MethodReference_lfno_primaryContext methodReference_lfno_primary() { - return getRuleContext(MethodReference_lfno_primaryContext.class, 0); - } - - public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() throws RecognitionException { - PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(_ctx, getState()); - enterRule(_localctx, 370, RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary); - int _la; - try { - setState(2033); - switch (getInterpreter().adaptivePredict(_input, 204, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1994); - literal(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1995); - typeName(); - setState(2000); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == LBRACK) { - { - { - setState(1996); - match(LBRACK); - setState(1997); - match(RBRACK); - } - } - setState(2002); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2003); - match(DOT); - setState(2004); - match(CLASS); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2006); - unannPrimitiveType(); - setState(2011); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == LBRACK) { - { - { - setState(2007); - match(LBRACK); - setState(2008); - match(RBRACK); - } - } - setState(2013); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2014); - match(DOT); - setState(2015); - match(CLASS); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(2017); - match(VOID); - setState(2018); - match(DOT); - setState(2019); - match(CLASS); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(2020); - match(THIS); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(2021); - typeName(); - setState(2022); - match(DOT); - setState(2023); - match(THIS); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(2025); - match(LPAREN); - setState(2026); - expression(); - setState(2027); - match(RPAREN); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(2029); - classInstanceCreationExpression_lfno_primary(); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(2030); - fieldAccess_lfno_primary(); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(2031); - methodInvocation_lfno_primary(); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(2032); - methodReference_lfno_primary(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassInstanceCreationExpressionContext extends ParserRuleContext { - public List<? extends TerminalNode> Identifier() { - return getTokens(Java8Parser.Identifier); - } - - public TerminalNode Identifier(int i) { - return getToken(Java8Parser.Identifier, i); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { - return getRuleContext(TypeArgumentsOrDiamondContext.class, 0); - } - - public ArgumentListContext argumentList() { - return getRuleContext(ArgumentListContext.class, 0); - } - - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class, 0); - } - - public ExpressionNameContext expressionName() { - return getRuleContext(ExpressionNameContext.class, 0); - } - - public PrimaryContext primary() { - return getRuleContext(PrimaryContext.class, 0); - } - - public ClassInstanceCreationExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classInstanceCreationExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassInstanceCreationExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassInstanceCreationExpressionContext classInstanceCreationExpression() throws RecognitionException { - ClassInstanceCreationExpressionContext _localctx = new ClassInstanceCreationExpressionContext(_ctx, getState()); - enterRule(_localctx, 372, RULE_classInstanceCreationExpression); - int _la; - try { - setState(2118); - switch (getInterpreter().adaptivePredict(_input, 222, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2035); - match(NEW); - setState(2037); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2036); - typeArguments(); - } - } - - setState(2042); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(2039); - annotation(); - } - } - setState(2044); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2045); - match(Identifier); - setState(2056); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == DOT) { - { - { - setState(2046); - match(DOT); - setState(2050); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(2047); - annotation(); - } - } - setState(2052); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2053); - match(Identifier); - } - } - setState(2058); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2060); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2059); - typeArgumentsOrDiamond(); - } - } - - setState(2062); - match(LPAREN); - setState(2064); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2063); - argumentList(); - } - } - - setState(2066); - match(RPAREN); - setState(2068); - _la = _input.LA(1); - if (_la == LBRACE) { - { - setState(2067); - classBody(); - } - } - - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2070); - expressionName(); - setState(2071); - match(DOT); - setState(2072); - match(NEW); - setState(2074); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2073); - typeArguments(); - } - } - - setState(2079); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(2076); - annotation(); - } - } - setState(2081); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2082); - match(Identifier); - setState(2084); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2083); - typeArgumentsOrDiamond(); - } - } - - setState(2086); - match(LPAREN); - setState(2088); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2087); - argumentList(); - } - } - - setState(2090); - match(RPAREN); - setState(2092); - _la = _input.LA(1); - if (_la == LBRACE) { - { - setState(2091); - classBody(); - } - } - - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2094); - primary(); - setState(2095); - match(DOT); - setState(2096); - match(NEW); - setState(2098); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2097); - typeArguments(); - } - } - - setState(2103); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(2100); - annotation(); - } - } - setState(2105); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2106); - match(Identifier); - setState(2108); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2107); - typeArgumentsOrDiamond(); - } - } - - setState(2110); - match(LPAREN); - setState(2112); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2111); - argumentList(); - } - } - - setState(2114); - match(RPAREN); - setState(2116); - _la = _input.LA(1); - if (_la == LBRACE) { - { - setState(2115); - classBody(); - } - } - - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassInstanceCreationExpression_lf_primaryContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { - return getRuleContext(TypeArgumentsOrDiamondContext.class, 0); - } - - public ArgumentListContext argumentList() { - return getRuleContext(ArgumentListContext.class, 0); - } - - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class, 0); - } - - public ClassInstanceCreationExpression_lf_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classInstanceCreationExpression_lf_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassInstanceCreationExpression_lf_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() throws RecognitionException { - ClassInstanceCreationExpression_lf_primaryContext _localctx = new ClassInstanceCreationExpression_lf_primaryContext(_ctx, getState()); - enterRule(_localctx, 374, RULE_classInstanceCreationExpression_lf_primary); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2120); - match(DOT); - setState(2121); - match(NEW); - setState(2123); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2122); - typeArguments(); - } - } - - setState(2128); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(2125); - annotation(); - } - } - setState(2130); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2131); - match(Identifier); - setState(2133); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2132); - typeArgumentsOrDiamond(); - } - } - - setState(2135); - match(LPAREN); - setState(2137); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BA [...] - { - setState(2136); - argumentList(); - } - } - - setState(2139); - match(RPAREN); - setState(2141); - switch (getInterpreter().adaptivePredict(_input, 227, _ctx)) { - case 1: { - setState(2140); - classBody(); - } - break; - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassInstanceCreationExpression_lfno_primaryContext extends ParserRuleContext { - public List<? extends TerminalNode> Identifier() { - return getTokens(Java8Parser.Identifier); - } - - public TerminalNode Identifier(int i) { - return getToken(Java8Parser.Identifier, i); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { - return getRuleContext(TypeArgumentsOrDiamondContext.class, 0); - } - - public ArgumentListContext argumentList() { - return getRuleContext(ArgumentListContext.class, 0); - } - - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class, 0); - } - - public ExpressionNameContext expressionName() { - return getRuleContext(ExpressionNameContext.class, 0); - } - - public ClassInstanceCreationExpression_lfno_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classInstanceCreationExpression_lfno_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitClassInstanceCreationExpression_lfno_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() throws RecognitionException { - ClassInstanceCreationExpression_lfno_primaryContext _localctx = new ClassInstanceCreationExpression_lfno_primaryContext(_ctx, getState()); - enterRule(_localctx, 376, RULE_classInstanceCreationExpression_lfno_primary); - int _la; - try { - setState(2202); - switch (_input.LA(1)) { - case NEW: - enterOuterAlt(_localctx, 1); - { - setState(2143); - match(NEW); - setState(2145); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2144); - typeArguments(); - } - } - - setState(2150); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(2147); - annotation(); - } - } - setState(2152); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2153); - match(Identifier); - setState(2164); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == DOT) { - { - { - setState(2154); - match(DOT); - setState(2158); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(2155); - annotation(); - } - } - setState(2160); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2161); - match(Identifier); - } - } - setState(2166); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2168); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2167); - typeArgumentsOrDiamond(); - } - } - - setState(2170); - match(LPAREN); - setState(2172); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2171); - argumentList(); - } - } - - setState(2174); - match(RPAREN); - setState(2176); - switch (getInterpreter().adaptivePredict(_input, 234, _ctx)) { - case 1: { - setState(2175); - classBody(); - } - break; - } - } - break; - case Identifier: - enterOuterAlt(_localctx, 2); - { - setState(2178); - expressionName(); - setState(2179); - match(DOT); - setState(2180); - match(NEW); - setState(2182); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2181); - typeArguments(); - } - } - - setState(2187); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(2184); - annotation(); - } - } - setState(2189); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2190); - match(Identifier); - setState(2192); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2191); - typeArgumentsOrDiamond(); - } - } - - setState(2194); - match(LPAREN); - setState(2196); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2195); - argumentList(); - } - } - - setState(2198); - match(RPAREN); - setState(2200); - switch (getInterpreter().adaptivePredict(_input, 239, _ctx)) { - case 1: { - setState(2199); - classBody(); - } - break; - } - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypeArgumentsOrDiamondContext extends ParserRuleContext { - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeArgumentsOrDiamond; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitTypeArgumentsOrDiamond(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException { - TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState()); - enterRule(_localctx, 378, RULE_typeArgumentsOrDiamond); - try { - setState(2207); - switch (getInterpreter().adaptivePredict(_input, 241, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2204); - typeArguments(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2205); - match(LT); - setState(2206); - match(GT); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class FieldAccessContext extends ParserRuleContext { - public PrimaryContext primary() { - return getRuleContext(PrimaryContext.class, 0); - } - - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public FieldAccessContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_fieldAccess; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitFieldAccess(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final FieldAccessContext fieldAccess() throws RecognitionException { - FieldAccessContext _localctx = new FieldAccessContext(_ctx, getState()); - enterRule(_localctx, 380, RULE_fieldAccess); - try { - setState(2222); - switch (getInterpreter().adaptivePredict(_input, 242, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2209); - primary(); - setState(2210); - match(DOT); - setState(2211); - match(Identifier); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2213); - match(SUPER); - setState(2214); - match(DOT); - setState(2215); - match(Identifier); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2216); - typeName(); - setState(2217); - match(DOT); - setState(2218); - match(SUPER); - setState(2219); - match(DOT); - setState(2220); - match(Identifier); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class FieldAccess_lf_primaryContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public FieldAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_fieldAccess_lf_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitFieldAccess_lf_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final FieldAccess_lf_primaryContext fieldAccess_lf_primary() throws RecognitionException { - FieldAccess_lf_primaryContext _localctx = new FieldAccess_lf_primaryContext(_ctx, getState()); - enterRule(_localctx, 382, RULE_fieldAccess_lf_primary); - try { - enterOuterAlt(_localctx, 1); - { - setState(2224); - match(DOT); - setState(2225); - match(Identifier); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class FieldAccess_lfno_primaryContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public FieldAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_fieldAccess_lfno_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitFieldAccess_lfno_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() throws RecognitionException { - FieldAccess_lfno_primaryContext _localctx = new FieldAccess_lfno_primaryContext(_ctx, getState()); - enterRule(_localctx, 384, RULE_fieldAccess_lfno_primary); - try { - setState(2236); - switch (_input.LA(1)) { - case SUPER: - enterOuterAlt(_localctx, 1); - { - setState(2227); - match(SUPER); - setState(2228); - match(DOT); - setState(2229); - match(Identifier); - } - break; - case Identifier: - enterOuterAlt(_localctx, 2); - { - setState(2230); - typeName(); - setState(2231); - match(DOT); - setState(2232); - match(SUPER); - setState(2233); - match(DOT); - setState(2234); - match(Identifier); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ArrayAccessContext extends ParserRuleContext { - public ExpressionNameContext expressionName() { - return getRuleContext(ExpressionNameContext.class, 0); - } - - public List<? extends ExpressionContext> expression() { - return getRuleContexts(ExpressionContext.class); - } - - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class, i); - } - - public PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() { - return getRuleContext(PrimaryNoNewArray_lfno_arrayAccessContext.class, 0); - } - - public List<? extends PrimaryNoNewArray_lf_arrayAccessContext> primaryNoNewArray_lf_arrayAccess() { - return getRuleContexts(PrimaryNoNewArray_lf_arrayAccessContext.class); - } - - public PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess(int i) { - return getRuleContext(PrimaryNoNewArray_lf_arrayAccessContext.class, i); - } - - public ArrayAccessContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_arrayAccess; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitArrayAccess(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ArrayAccessContext arrayAccess() throws RecognitionException { - ArrayAccessContext _localctx = new ArrayAccessContext(_ctx, getState()); - enterRule(_localctx, 386, RULE_arrayAccess); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2248); - switch (getInterpreter().adaptivePredict(_input, 244, _ctx)) { - case 1: { - setState(2238); - expressionName(); - setState(2239); - match(LBRACK); - setState(2240); - expression(); - setState(2241); - match(RBRACK); - } - break; - case 2: { - setState(2243); - primaryNoNewArray_lfno_arrayAccess(); - setState(2244); - match(LBRACK); - setState(2245); - expression(); - setState(2246); - match(RBRACK); - } - break; - } - setState(2257); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == LBRACK) { - { - { - setState(2250); - primaryNoNewArray_lf_arrayAccess(); - setState(2251); - match(LBRACK); - setState(2252); - expression(); - setState(2253); - match(RBRACK); - } - } - setState(2259); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ArrayAccess_lf_primaryContext extends ParserRuleContext { - public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() { - return getRuleContext(PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext.class, 0); - } - - public List<? extends ExpressionContext> expression() { - return getRuleContexts(ExpressionContext.class); - } - - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class, i); - } - - public List<? extends PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext> primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() { - return getRuleContexts(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class); - } - - public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(int i) { - return getRuleContext(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class, i); - } - - public ArrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_arrayAccess_lf_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitArrayAccess_lf_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ArrayAccess_lf_primaryContext arrayAccess_lf_primary() throws RecognitionException { - ArrayAccess_lf_primaryContext _localctx = new ArrayAccess_lf_primaryContext(_ctx, getState()); - enterRule(_localctx, 388, RULE_arrayAccess_lf_primary); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(2260); - primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(); - setState(2261); - match(LBRACK); - setState(2262); - expression(); - setState(2263); - match(RBRACK); - } - setState(2272); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 246, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(2265); - primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(); - setState(2266); - match(LBRACK); - setState(2267); - expression(); - setState(2268); - match(RBRACK); - } - } - } - setState(2274); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 246, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ArrayAccess_lfno_primaryContext extends ParserRuleContext { - public ExpressionNameContext expressionName() { - return getRuleContext(ExpressionNameContext.class, 0); - } - - public List<? extends ExpressionContext> expression() { - return getRuleContexts(ExpressionContext.class); - } - - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class, i); - } - - public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() { - return getRuleContext(PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext.class, 0); - } - - public List<? extends PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext> primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() { - return getRuleContexts(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class); - } - - public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(int i) { - return getRuleContext(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class, i); - } - - public ArrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_arrayAccess_lfno_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitArrayAccess_lfno_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() throws RecognitionException { - ArrayAccess_lfno_primaryContext _localctx = new ArrayAccess_lfno_primaryContext(_ctx, getState()); - enterRule(_localctx, 390, RULE_arrayAccess_lfno_primary); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2285); - switch (getInterpreter().adaptivePredict(_input, 247, _ctx)) { - case 1: { - setState(2275); - expressionName(); - setState(2276); - match(LBRACK); - setState(2277); - expression(); - setState(2278); - match(RBRACK); - } - break; - case 2: { - setState(2280); - primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(); - setState(2281); - match(LBRACK); - setState(2282); - expression(); - setState(2283); - match(RBRACK); - } - break; - } - setState(2294); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 248, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(2287); - primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(); - setState(2288); - match(LBRACK); - setState(2289); - expression(); - setState(2290); - match(RBRACK); - } - } - } - setState(2296); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 248, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodInvocationContext extends ParserRuleContext { - public MethodNameContext methodName() { - return getRuleContext(MethodNameContext.class, 0); - } - - public ArgumentListContext argumentList() { - return getRuleContext(ArgumentListContext.class, 0); - } - - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public ExpressionNameContext expressionName() { - return getRuleContext(ExpressionNameContext.class, 0); - } - - public PrimaryContext primary() { - return getRuleContext(PrimaryContext.class, 0); - } - - public MethodInvocationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodInvocation; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodInvocation(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodInvocationContext methodInvocation() throws RecognitionException { - MethodInvocationContext _localctx = new MethodInvocationContext(_ctx, getState()); - enterRule(_localctx, 392, RULE_methodInvocation); - int _la; - try { - setState(2365); - switch (getInterpreter().adaptivePredict(_input, 260, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2297); - methodName(); - setState(2298); - match(LPAREN); - setState(2300); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2299); - argumentList(); - } - } - - setState(2302); - match(RPAREN); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2304); - typeName(); - setState(2305); - match(DOT); - setState(2307); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2306); - typeArguments(); - } - } - - setState(2309); - match(Identifier); - setState(2310); - match(LPAREN); - setState(2312); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2311); - argumentList(); - } - } - - setState(2314); - match(RPAREN); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2316); - expressionName(); - setState(2317); - match(DOT); - setState(2319); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2318); - typeArguments(); - } - } - - setState(2321); - match(Identifier); - setState(2322); - match(LPAREN); - setState(2324); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2323); - argumentList(); - } - } - - setState(2326); - match(RPAREN); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(2328); - primary(); - setState(2329); - match(DOT); - setState(2331); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2330); - typeArguments(); - } - } - - setState(2333); - match(Identifier); - setState(2334); - match(LPAREN); - setState(2336); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2335); - argumentList(); - } - } - - setState(2338); - match(RPAREN); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(2340); - match(SUPER); - setState(2341); - match(DOT); - setState(2343); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2342); - typeArguments(); - } - } - - setState(2345); - match(Identifier); - setState(2346); - match(LPAREN); - setState(2348); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2347); - argumentList(); - } - } - - setState(2350); - match(RPAREN); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(2351); - typeName(); - setState(2352); - match(DOT); - setState(2353); - match(SUPER); - setState(2354); - match(DOT); - setState(2356); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2355); - typeArguments(); - } - } - - setState(2358); - match(Identifier); - setState(2359); - match(LPAREN); - setState(2361); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2360); - argumentList(); - } - } - - setState(2363); - match(RPAREN); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodInvocation_lf_primaryContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public ArgumentListContext argumentList() { - return getRuleContext(ArgumentListContext.class, 0); - } - - public MethodInvocation_lf_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodInvocation_lf_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodInvocation_lf_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodInvocation_lf_primaryContext methodInvocation_lf_primary() throws RecognitionException { - MethodInvocation_lf_primaryContext _localctx = new MethodInvocation_lf_primaryContext(_ctx, getState()); - enterRule(_localctx, 394, RULE_methodInvocation_lf_primary); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2367); - match(DOT); - setState(2369); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2368); - typeArguments(); - } - } - - setState(2371); - match(Identifier); - setState(2372); - match(LPAREN); - setState(2374); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BA [...] - { - setState(2373); - argumentList(); - } - } - - setState(2376); - match(RPAREN); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodInvocation_lfno_primaryContext extends ParserRuleContext { - public MethodNameContext methodName() { - return getRuleContext(MethodNameContext.class, 0); - } - - public ArgumentListContext argumentList() { - return getRuleContext(ArgumentListContext.class, 0); - } - - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public ExpressionNameContext expressionName() { - return getRuleContext(ExpressionNameContext.class, 0); - } - - public MethodInvocation_lfno_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodInvocation_lfno_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodInvocation_lfno_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() throws RecognitionException { - MethodInvocation_lfno_primaryContext _localctx = new MethodInvocation_lfno_primaryContext(_ctx, getState()); - enterRule(_localctx, 396, RULE_methodInvocation_lfno_primary); - int _la; - try { - setState(2434); - switch (getInterpreter().adaptivePredict(_input, 272, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2378); - methodName(); - setState(2379); - match(LPAREN); - setState(2381); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2380); - argumentList(); - } - } - - setState(2383); - match(RPAREN); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2385); - typeName(); - setState(2386); - match(DOT); - setState(2388); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2387); - typeArguments(); - } - } - - setState(2390); - match(Identifier); - setState(2391); - match(LPAREN); - setState(2393); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2392); - argumentList(); - } - } - - setState(2395); - match(RPAREN); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2397); - expressionName(); - setState(2398); - match(DOT); - setState(2400); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2399); - typeArguments(); - } - } - - setState(2402); - match(Identifier); - setState(2403); - match(LPAREN); - setState(2405); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2404); - argumentList(); - } - } - - setState(2407); - match(RPAREN); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(2409); - match(SUPER); - setState(2410); - match(DOT); - setState(2412); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2411); - typeArguments(); - } - } - - setState(2414); - match(Identifier); - setState(2415); - match(LPAREN); - setState(2417); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2416); - argumentList(); - } - } - - setState(2419); - match(RPAREN); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(2420); - typeName(); - setState(2421); - match(DOT); - setState(2422); - match(SUPER); - setState(2423); - match(DOT); - setState(2425); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2424); - typeArguments(); - } - } - - setState(2427); - match(Identifier); - setState(2428); - match(LPAREN); - setState(2430); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] - { - setState(2429); - argumentList(); - } - } - - setState(2432); - match(RPAREN); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ArgumentListContext extends ParserRuleContext { - public List<? extends ExpressionContext> expression() { - return getRuleContexts(ExpressionContext.class); - } - - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class, i); - } - - public ArgumentListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_argumentList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitArgumentList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ArgumentListContext argumentList() throws RecognitionException { - ArgumentListContext _localctx = new ArgumentListContext(_ctx, getState()); - enterRule(_localctx, 398, RULE_argumentList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2436); - expression(); - setState(2441); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(2437); - match(COMMA); - setState(2438); - expression(); - } - } - setState(2443); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodReferenceContext extends ParserRuleContext { - public ExpressionNameContext expressionName() { - return getRuleContext(ExpressionNameContext.class, 0); - } - - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public ReferenceTypeContext referenceType() { - return getRuleContext(ReferenceTypeContext.class, 0); - } - - public PrimaryContext primary() { - return getRuleContext(PrimaryContext.class, 0); - } - - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public ClassTypeContext classType() { - return getRuleContext(ClassTypeContext.class, 0); - } - - public ArrayTypeContext arrayType() { - return getRuleContext(ArrayTypeContext.class, 0); - } - - public MethodReferenceContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodReference; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodReference(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodReferenceContext methodReference() throws RecognitionException { - MethodReferenceContext _localctx = new MethodReferenceContext(_ctx, getState()); - enterRule(_localctx, 400, RULE_methodReference); - int _la; - try { - setState(2491); - switch (getInterpreter().adaptivePredict(_input, 280, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2444); - expressionName(); - setState(2445); - match(COLONCOLON); - setState(2447); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2446); - typeArguments(); - } - } - - setState(2449); - match(Identifier); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2451); - referenceType(); - setState(2452); - match(COLONCOLON); - setState(2454); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2453); - typeArguments(); - } - } - - setState(2456); - match(Identifier); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2458); - primary(); - setState(2459); - match(COLONCOLON); - setState(2461); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2460); - typeArguments(); - } - } - - setState(2463); - match(Identifier); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(2465); - match(SUPER); - setState(2466); - match(COLONCOLON); - setState(2468); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2467); - typeArguments(); - } - } - - setState(2470); - match(Identifier); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(2471); - typeName(); - setState(2472); - match(DOT); - setState(2473); - match(SUPER); - setState(2474); - match(COLONCOLON); - setState(2476); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2475); - typeArguments(); - } - } - - setState(2478); - match(Identifier); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(2480); - classType(); - setState(2481); - match(COLONCOLON); - setState(2483); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2482); - typeArguments(); - } - } - - setState(2485); - match(NEW); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(2487); - arrayType(); - setState(2488); - match(COLONCOLON); - setState(2489); - match(NEW); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodReference_lf_primaryContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public MethodReference_lf_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodReference_lf_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodReference_lf_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodReference_lf_primaryContext methodReference_lf_primary() throws RecognitionException { - MethodReference_lf_primaryContext _localctx = new MethodReference_lf_primaryContext(_ctx, getState()); - enterRule(_localctx, 402, RULE_methodReference_lf_primary); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2493); - match(COLONCOLON); - setState(2495); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2494); - typeArguments(); - } - } - - setState(2497); - match(Identifier); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class MethodReference_lfno_primaryContext extends ParserRuleContext { - public ExpressionNameContext expressionName() { - return getRuleContext(ExpressionNameContext.class, 0); - } - - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public ReferenceTypeContext referenceType() { - return getRuleContext(ReferenceTypeContext.class, 0); - } - - public TypeNameContext typeName() { - return getRuleContext(TypeNameContext.class, 0); - } - - public ClassTypeContext classType() { - return getRuleContext(ClassTypeContext.class, 0); - } - - public ArrayTypeContext arrayType() { - return getRuleContext(ArrayTypeContext.class, 0); - } - - public MethodReference_lfno_primaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodReference_lfno_primary; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMethodReference_lfno_primary(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MethodReference_lfno_primaryContext methodReference_lfno_primary() throws RecognitionException { - MethodReference_lfno_primaryContext _localctx = new MethodReference_lfno_primaryContext(_ctx, getState()); - enterRule(_localctx, 404, RULE_methodReference_lfno_primary); - int _la; - try { - setState(2539); - switch (getInterpreter().adaptivePredict(_input, 287, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2499); - expressionName(); - setState(2500); - match(COLONCOLON); - setState(2502); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2501); - typeArguments(); - } - } - - setState(2504); - match(Identifier); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2506); - referenceType(); - setState(2507); - match(COLONCOLON); - setState(2509); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2508); - typeArguments(); - } - } - - setState(2511); - match(Identifier); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2513); - match(SUPER); - setState(2514); - match(COLONCOLON); - setState(2516); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2515); - typeArguments(); - } - } - - setState(2518); - match(Identifier); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(2519); - typeName(); - setState(2520); - match(DOT); - setState(2521); - match(SUPER); - setState(2522); - match(COLONCOLON); - setState(2524); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2523); - typeArguments(); - } - } - - setState(2526); - match(Identifier); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(2528); - classType(); - setState(2529); - match(COLONCOLON); - setState(2531); - _la = _input.LA(1); - if (_la == LT) { - { - setState(2530); - typeArguments(); - } - } - - setState(2533); - match(NEW); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(2535); - arrayType(); - setState(2536); - match(COLONCOLON); - setState(2537); - match(NEW); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ArrayCreationExpressionContext extends ParserRuleContext { - public PrimitiveTypeContext primitiveType() { - return getRuleContext(PrimitiveTypeContext.class, 0); - } - - public DimExprsContext dimExprs() { - return getRuleContext(DimExprsContext.class, 0); - } - - public DimsContext dims() { - return getRuleContext(DimsContext.class, 0); - } - - public ClassOrInterfaceTypeContext classOrInterfaceType() { - return getRuleContext(ClassOrInterfaceTypeContext.class, 0); - } - - public ArrayInitializerContext arrayInitializer() { - return getRuleContext(ArrayInitializerContext.class, 0); - } - - public ArrayCreationExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_arrayCreationExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitArrayCreationExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ArrayCreationExpressionContext arrayCreationExpression() throws RecognitionException { - ArrayCreationExpressionContext _localctx = new ArrayCreationExpressionContext(_ctx, getState()); - enterRule(_localctx, 406, RULE_arrayCreationExpression); - try { - setState(2563); - switch (getInterpreter().adaptivePredict(_input, 290, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2541); - match(NEW); - setState(2542); - primitiveType(); - setState(2543); - dimExprs(); - setState(2545); - switch (getInterpreter().adaptivePredict(_input, 288, _ctx)) { - case 1: { - setState(2544); - dims(); - } - break; - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2547); - match(NEW); - setState(2548); - classOrInterfaceType(); - setState(2549); - dimExprs(); - setState(2551); - switch (getInterpreter().adaptivePredict(_input, 289, _ctx)) { - case 1: { - setState(2550); - dims(); - } - break; - } - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2553); - match(NEW); - setState(2554); - primitiveType(); - setState(2555); - dims(); - setState(2556); - arrayInitializer(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(2558); - match(NEW); - setState(2559); - classOrInterfaceType(); - setState(2560); - dims(); - setState(2561); - arrayInitializer(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class DimExprsContext extends ParserRuleContext { - public List<? extends DimExprContext> dimExpr() { - return getRuleContexts(DimExprContext.class); - } - - public DimExprContext dimExpr(int i) { - return getRuleContext(DimExprContext.class, i); - } - - public DimExprsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_dimExprs; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitDimExprs(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final DimExprsContext dimExprs() throws RecognitionException { - DimExprsContext _localctx = new DimExprsContext(_ctx, getState()); - enterRule(_localctx, 408, RULE_dimExprs); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2565); - dimExpr(); - setState(2569); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 291, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(2566); - dimExpr(); - } - } - } - setState(2571); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 291, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class DimExprContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public List<? extends AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public DimExprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_dimExpr; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitDimExpr(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final DimExprContext dimExpr() throws RecognitionException { - DimExprContext _localctx = new DimExprContext(_ctx, getState()); - enterRule(_localctx, 410, RULE_dimExpr); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2575); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT) { - { - { - setState(2572); - annotation(); - } - } - setState(2577); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2578); - match(LBRACK); - setState(2579); - expression(); - setState(2580); - match(RBRACK); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ConstantExpressionContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ConstantExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_constantExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitConstantExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ConstantExpressionContext constantExpression() throws RecognitionException { - ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState()); - enterRule(_localctx, 412, RULE_constantExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(2582); - expression(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ExpressionContext extends ParserRuleContext { - public LambdaExpressionContext lambdaExpression() { - return getRuleContext(LambdaExpressionContext.class, 0); - } - - public AssignmentExpressionContext assignmentExpression() { - return getRuleContext(AssignmentExpressionContext.class, 0); - } - - public ExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_expression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ExpressionContext expression() throws RecognitionException { - ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); - enterRule(_localctx, 414, RULE_expression); - try { - setState(2586); - switch (getInterpreter().adaptivePredict(_input, 293, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2584); - lambdaExpression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2585); - assignmentExpression(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class LambdaExpressionContext extends ParserRuleContext { - public LambdaParametersContext lambdaParameters() { - return getRuleContext(LambdaParametersContext.class, 0); - } - - public LambdaBodyContext lambdaBody() { - return getRuleContext(LambdaBodyContext.class, 0); - } - - public LambdaExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_lambdaExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitLambdaExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final LambdaExpressionContext lambdaExpression() throws RecognitionException { - LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState()); - enterRule(_localctx, 416, RULE_lambdaExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(2588); - lambdaParameters(); - setState(2589); - match(ARROW); - setState(2590); - lambdaBody(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class LambdaParametersContext extends ParserRuleContext { - public TerminalNode Identifier() { - return getToken(Java8Parser.Identifier, 0); - } - - public FormalParameterListContext formalParameterList() { - return getRuleContext(FormalParameterListContext.class, 0); - } - - public InferredFormalParameterListContext inferredFormalParameterList() { - return getRuleContext(InferredFormalParameterListContext.class, 0); - } - - public LambdaParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_lambdaParameters; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitLambdaParameters(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final LambdaParametersContext lambdaParameters() throws RecognitionException { - LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState()); - enterRule(_localctx, 418, RULE_lambdaParameters); - int _la; - try { - setState(2602); - switch (getInterpreter().adaptivePredict(_input, 295, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2592); - match(Identifier); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2593); - match(LPAREN); - setState(2595); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la == Identifier || _la == AT) { - { - setState(2594); - formalParameterList(); - } - } - - setState(2597); - match(RPAREN); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2598); - match(LPAREN); - setState(2599); - inferredFormalParameterList(); - setState(2600); - match(RPAREN); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class InferredFormalParameterListContext extends ParserRuleContext { - public List<? extends TerminalNode> Identifier() { - return getTokens(Java8Parser.Identifier); - } - - public TerminalNode Identifier(int i) { - return getToken(Java8Parser.Identifier, i); - } - - public InferredFormalParameterListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_inferredFormalParameterList; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInferredFormalParameterList(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InferredFormalParameterListContext inferredFormalParameterList() throws RecognitionException { - InferredFormalParameterListContext _localctx = new InferredFormalParameterListContext(_ctx, getState()); - enterRule(_localctx, 420, RULE_inferredFormalParameterList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2604); - match(Identifier); - setState(2609); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(2605); - match(COMMA); - setState(2606); - match(Identifier); - } - } - setState(2611); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class LambdaBodyContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public LambdaBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_lambdaBody; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitLambdaBody(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final LambdaBodyContext lambdaBody() throws RecognitionException { - LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState()); - enterRule(_localctx, 422, RULE_lambdaBody); - try { - setState(2614); - switch (_input.LA(1)) { - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case NEW: - case SHORT: - case SUPER: - case THIS: - case VOID: - case IntegerLiteral: - case FloatingPointLiteral: - case BooleanLiteral: - case CharacterLiteral: - case StringLiteral: - case NullLiteral: - case LPAREN: - case BANG: - case TILDE: - case INC: - case DEC: - case ADD: - case SUB: - case Identifier: - case AT: - enterOuterAlt(_localctx, 1); - { - setState(2612); - expression(); - } - break; - case LBRACE: - enterOuterAlt(_localctx, 2); - { - setState(2613); - block(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AssignmentExpressionContext extends ParserRuleContext { - public ConditionalExpressionContext conditionalExpression() { - return getRuleContext(ConditionalExpressionContext.class, 0); - } - - public AssignmentContext assignment() { - return getRuleContext(AssignmentContext.class, 0); - } - - public AssignmentExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_assignmentExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAssignmentExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AssignmentExpressionContext assignmentExpression() throws RecognitionException { - AssignmentExpressionContext _localctx = new AssignmentExpressionContext(_ctx, getState()); - enterRule(_localctx, 424, RULE_assignmentExpression); - try { - setState(2618); - switch (getInterpreter().adaptivePredict(_input, 298, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2616); - conditionalExpression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2617); - assignment(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AssignmentContext extends ParserRuleContext { - public LeftHandSideContext leftHandSide() { - return getRuleContext(LeftHandSideContext.class, 0); - } - - public AssignmentOperatorContext assignmentOperator() { - return getRuleContext(AssignmentOperatorContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public AssignmentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_assignment; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAssignment(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AssignmentContext assignment() throws RecognitionException { - AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); - enterRule(_localctx, 426, RULE_assignment); - try { - enterOuterAlt(_localctx, 1); - { - setState(2620); - leftHandSide(); - setState(2621); - assignmentOperator(); - setState(2622); - expression(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class LeftHandSideContext extends ParserRuleContext { - public ExpressionNameContext expressionName() { - return getRuleContext(ExpressionNameContext.class, 0); - } - - public FieldAccessContext fieldAccess() { - return getRuleContext(FieldAccessContext.class, 0); - } - - public ArrayAccessContext arrayAccess() { - return getRuleContext(ArrayAccessContext.class, 0); - } - - public LeftHandSideContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_leftHandSide; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitLeftHandSide(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final LeftHandSideContext leftHandSide() throws RecognitionException { - LeftHandSideContext _localctx = new LeftHandSideContext(_ctx, getState()); - enterRule(_localctx, 428, RULE_leftHandSide); - try { - setState(2627); - switch (getInterpreter().adaptivePredict(_input, 299, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2624); - expressionName(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2625); - fieldAccess(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2626); - arrayAccess(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AssignmentOperatorContext extends ParserRuleContext { - public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_assignmentOperator; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAssignmentOperator(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AssignmentOperatorContext assignmentOperator() throws RecognitionException { - AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState()); - enterRule(_localctx, 430, RULE_assignmentOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2629); - _la = _input.LA(1); - if (!(((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ASSIGN - 66)) | (1L << (ADD_ASSIGN - 66)) | (1L << (SUB_ASSIGN - 66)) | (1L << (MUL_ASSIGN - 66)) | (1L << (DIV_ASSIGN - 66)) | (1L << (AND_ASSIGN - 66)) | (1L << (OR_ASSIGN - 66)) | (1L << (XOR_ASSIGN - 66)) | (1L << (MOD_ASSIGN - 66)) | (1L << (LSHIFT_ASSIGN - 66)) | (1L << (RSHIFT_ASSIGN - 66)) | (1L << (URSHIFT_ASSIGN - 66)))) != 0))) { - _errHandler.recoverInline(this); - } else { - consume(); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ConditionalExpressionContext extends ParserRuleContext { - public ConditionalOrExpressionContext conditionalOrExpression() { - return getRuleContext(ConditionalOrExpressionContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ConditionalExpressionContext conditionalExpression() { - return getRuleContext(ConditionalExpressionContext.class, 0); - } - - public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_conditionalExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitConditionalExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ConditionalExpressionContext conditionalExpression() throws RecognitionException { - ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState()); - enterRule(_localctx, 432, RULE_conditionalExpression); - try { - setState(2638); - switch (getInterpreter().adaptivePredict(_input, 300, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2631); - conditionalOrExpression(0); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2632); - conditionalOrExpression(0); - setState(2633); - match(QUESTION); - setState(2634); - expression(); - setState(2635); - match(COLON); - setState(2636); - conditionalExpression(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ConditionalOrExpressionContext extends ParserRuleContext { - public ConditionalAndExpressionContext conditionalAndExpression() { - return getRuleContext(ConditionalAndExpressionContext.class, 0); - } - - public ConditionalOrExpressionContext conditionalOrExpression() { - return getRuleContext(ConditionalOrExpressionContext.class, 0); - } - - public ConditionalOrExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_conditionalOrExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitConditionalOrExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ConditionalOrExpressionContext conditionalOrExpression() throws RecognitionException { - return conditionalOrExpression(0); - } - - private ConditionalOrExpressionContext conditionalOrExpression(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - ConditionalOrExpressionContext _localctx = new ConditionalOrExpressionContext(_ctx, _parentState); - ConditionalOrExpressionContext _prevctx = _localctx; - int _startState = 434; - enterRecursionRule(_localctx, 434, RULE_conditionalOrExpression, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(2641); - conditionalAndExpression(0); - } - _ctx.stop = _input.LT(-1); - setState(2648); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 301, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - { - _localctx = new ConditionalOrExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_conditionalOrExpression); - setState(2643); - if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(2644); - match(OR); - setState(2645); - conditionalAndExpression(0); - } - } - } - setState(2650); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 301, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class ConditionalAndExpressionContext extends ParserRuleContext { - public InclusiveOrExpressionContext inclusiveOrExpression() { - return getRuleContext(InclusiveOrExpressionContext.class, 0); - } - - public ConditionalAndExpressionContext conditionalAndExpression() { - return getRuleContext(ConditionalAndExpressionContext.class, 0); - } - - public ConditionalAndExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_conditionalAndExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitConditionalAndExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ConditionalAndExpressionContext conditionalAndExpression() throws RecognitionException { - return conditionalAndExpression(0); - } - - private ConditionalAndExpressionContext conditionalAndExpression(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - ConditionalAndExpressionContext _localctx = new ConditionalAndExpressionContext(_ctx, _parentState); - ConditionalAndExpressionContext _prevctx = _localctx; - int _startState = 436; - enterRecursionRule(_localctx, 436, RULE_conditionalAndExpression, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(2652); - inclusiveOrExpression(0); - } - _ctx.stop = _input.LT(-1); - setState(2659); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 302, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - { - _localctx = new ConditionalAndExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_conditionalAndExpression); - setState(2654); - if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(2655); - match(AND); - setState(2656); - inclusiveOrExpression(0); - } - } - } - setState(2661); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 302, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class InclusiveOrExpressionContext extends ParserRuleContext { - public ExclusiveOrExpressionContext exclusiveOrExpression() { - return getRuleContext(ExclusiveOrExpressionContext.class, 0); - } - - public InclusiveOrExpressionContext inclusiveOrExpression() { - return getRuleContext(InclusiveOrExpressionContext.class, 0); - } - - public InclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_inclusiveOrExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitInclusiveOrExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final InclusiveOrExpressionContext inclusiveOrExpression() throws RecognitionException { - return inclusiveOrExpression(0); - } - - private InclusiveOrExpressionContext inclusiveOrExpression(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - InclusiveOrExpressionContext _localctx = new InclusiveOrExpressionContext(_ctx, _parentState); - InclusiveOrExpressionContext _prevctx = _localctx; - int _startState = 438; - enterRecursionRule(_localctx, 438, RULE_inclusiveOrExpression, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(2663); - exclusiveOrExpression(0); - } - _ctx.stop = _input.LT(-1); - setState(2670); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 303, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - { - _localctx = new InclusiveOrExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_inclusiveOrExpression); - setState(2665); - if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(2666); - match(BITOR); - setState(2667); - exclusiveOrExpression(0); - } - } - } - setState(2672); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 303, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class ExclusiveOrExpressionContext extends ParserRuleContext { - public AndExpressionContext andExpression() { - return getRuleContext(AndExpressionContext.class, 0); - } - - public ExclusiveOrExpressionContext exclusiveOrExpression() { - return getRuleContext(ExclusiveOrExpressionContext.class, 0); - } - - public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_exclusiveOrExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitExclusiveOrExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ExclusiveOrExpressionContext exclusiveOrExpression() throws RecognitionException { - return exclusiveOrExpression(0); - } - - private ExclusiveOrExpressionContext exclusiveOrExpression(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(_ctx, _parentState); - ExclusiveOrExpressionContext _prevctx = _localctx; - int _startState = 440; - enterRecursionRule(_localctx, 440, RULE_exclusiveOrExpression, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(2674); - andExpression(0); - } - _ctx.stop = _input.LT(-1); - setState(2681); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 304, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - { - _localctx = new ExclusiveOrExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_exclusiveOrExpression); - setState(2676); - if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(2677); - match(CARET); - setState(2678); - andExpression(0); - } - } - } - setState(2683); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 304, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class AndExpressionContext extends ParserRuleContext { - public EqualityExpressionContext equalityExpression() { - return getRuleContext(EqualityExpressionContext.class, 0); - } - - public AndExpressionContext andExpression() { - return getRuleContext(AndExpressionContext.class, 0); - } - - public AndExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_andExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAndExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AndExpressionContext andExpression() throws RecognitionException { - return andExpression(0); - } - - private AndExpressionContext andExpression(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - AndExpressionContext _localctx = new AndExpressionContext(_ctx, _parentState); - AndExpressionContext _prevctx = _localctx; - int _startState = 442; - enterRecursionRule(_localctx, 442, RULE_andExpression, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(2685); - equalityExpression(0); - } - _ctx.stop = _input.LT(-1); - setState(2692); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 305, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - { - _localctx = new AndExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_andExpression); - setState(2687); - if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(2688); - match(BITAND); - setState(2689); - equalityExpression(0); - } - } - } - setState(2694); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 305, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class EqualityExpressionContext extends ParserRuleContext { - public RelationalExpressionContext relationalExpression() { - return getRuleContext(RelationalExpressionContext.class, 0); - } - - public EqualityExpressionContext equalityExpression() { - return getRuleContext(EqualityExpressionContext.class, 0); - } - - public EqualityExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_equalityExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitEqualityExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final EqualityExpressionContext equalityExpression() throws RecognitionException { - return equalityExpression(0); - } - - private EqualityExpressionContext equalityExpression(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - EqualityExpressionContext _localctx = new EqualityExpressionContext(_ctx, _parentState); - EqualityExpressionContext _prevctx = _localctx; - int _startState = 444; - enterRecursionRule(_localctx, 444, RULE_equalityExpression, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(2696); - relationalExpression(0); - } - _ctx.stop = _input.LT(-1); - setState(2706); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 307, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - setState(2704); - switch (getInterpreter().adaptivePredict(_input, 306, _ctx)) { - case 1: { - _localctx = new EqualityExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression); - setState(2698); - if (!(precpred(_ctx, 2))) - throw new FailedPredicateException(this, "precpred(_ctx, 2)"); - setState(2699); - match(EQUAL); - setState(2700); - relationalExpression(0); - } - break; - case 2: { - _localctx = new EqualityExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression); - setState(2701); - if (!(precpred(_ctx, 1))) - throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(2702); - match(NOTEQUAL); - setState(2703); - relationalExpression(0); - } - break; - } - } - } - setState(2708); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 307, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class RelationalExpressionContext extends ParserRuleContext { - public ShiftExpressionContext shiftExpression() { - return getRuleContext(ShiftExpressionContext.class, 0); - } - - public RelationalExpressionContext relationalExpression() { - return getRuleContext(RelationalExpressionContext.class, 0); - } - - public ReferenceTypeContext referenceType() { - return getRuleContext(ReferenceTypeContext.class, 0); - } - - public RelationalExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_relationalExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitRelationalExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final RelationalExpressionContext relationalExpression() throws RecognitionException { - return relationalExpression(0); - } - - private RelationalExpressionContext relationalExpression(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, _parentState); - RelationalExpressionContext _prevctx = _localctx; - int _startState = 446; - enterRecursionRule(_localctx, 446, RULE_relationalExpression, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(2710); - shiftExpression(0); - } - _ctx.stop = _input.LT(-1); - setState(2729); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 309, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - setState(2727); - switch (getInterpreter().adaptivePredict(_input, 308, _ctx)) { - case 1: { - _localctx = new RelationalExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); - setState(2712); - if (!(precpred(_ctx, 5))) - throw new FailedPredicateException(this, "precpred(_ctx, 5)"); - setState(2713); - match(LT); - setState(2714); - shiftExpression(0); - } - break; - case 2: { - _localctx = new RelationalExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); - setState(2715); - if (!(precpred(_ctx, 4))) - throw new FailedPredicateException(this, "precpred(_ctx, 4)"); - setState(2716); - match(GT); - setState(2717); - shiftExpression(0); - } - break; - case 3: { - _localctx = new RelationalExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); - setState(2718); - if (!(precpred(_ctx, 3))) - throw new FailedPredicateException(this, "precpred(_ctx, 3)"); - setState(2719); - match(LE); - setState(2720); - shiftExpression(0); - } - break; - case 4: { - _localctx = new RelationalExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); - setState(2721); - if (!(precpred(_ctx, 2))) - throw new FailedPredicateException(this, "precpred(_ctx, 2)"); - setState(2722); - match(GE); - setState(2723); - shiftExpression(0); - } - break; - case 5: { - _localctx = new RelationalExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); - setState(2724); - if (!(precpred(_ctx, 1))) - throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(2725); - match(INSTANCEOF); - setState(2726); - referenceType(); - } - break; - } - } - } - setState(2731); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 309, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class ShiftExpressionContext extends ParserRuleContext { - public AdditiveExpressionContext additiveExpression() { - return getRuleContext(AdditiveExpressionContext.class, 0); - } - - public ShiftExpressionContext shiftExpression() { - return getRuleContext(ShiftExpressionContext.class, 0); - } - - public ShiftExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_shiftExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitShiftExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final ShiftExpressionContext shiftExpression() throws RecognitionException { - return shiftExpression(0); - } - - private ShiftExpressionContext shiftExpression(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - ShiftExpressionContext _localctx = new ShiftExpressionContext(_ctx, _parentState); - ShiftExpressionContext _prevctx = _localctx; - int _startState = 448; - enterRecursionRule(_localctx, 448, RULE_shiftExpression, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(2733); - additiveExpression(0); - } - _ctx.stop = _input.LT(-1); - setState(2750); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 311, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - setState(2748); - switch (getInterpreter().adaptivePredict(_input, 310, _ctx)) { - case 1: { - _localctx = new ShiftExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); - setState(2735); - if (!(precpred(_ctx, 3))) - throw new FailedPredicateException(this, "precpred(_ctx, 3)"); - setState(2736); - match(LT); - setState(2737); - match(LT); - setState(2738); - additiveExpression(0); - } - break; - case 2: { - _localctx = new ShiftExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); - setState(2739); - if (!(precpred(_ctx, 2))) - throw new FailedPredicateException(this, "precpred(_ctx, 2)"); - setState(2740); - match(GT); - setState(2741); - match(GT); - setState(2742); - additiveExpression(0); - } - break; - case 3: { - _localctx = new ShiftExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); - setState(2743); - if (!(precpred(_ctx, 1))) - throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(2744); - match(GT); - setState(2745); - match(GT); - setState(2746); - match(GT); - setState(2747); - additiveExpression(0); - } - break; - } - } - } - setState(2752); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 311, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class AdditiveExpressionContext extends ParserRuleContext { - public MultiplicativeExpressionContext multiplicativeExpression() { - return getRuleContext(MultiplicativeExpressionContext.class, 0); - } - - public AdditiveExpressionContext additiveExpression() { - return getRuleContext(AdditiveExpressionContext.class, 0); - } - - public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_additiveExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitAdditiveExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final AdditiveExpressionContext additiveExpression() throws RecognitionException { - return additiveExpression(0); - } - - private AdditiveExpressionContext additiveExpression(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, _parentState); - AdditiveExpressionContext _prevctx = _localctx; - int _startState = 450; - enterRecursionRule(_localctx, 450, RULE_additiveExpression, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(2754); - multiplicativeExpression(0); - } - _ctx.stop = _input.LT(-1); - setState(2764); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 313, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - setState(2762); - switch (getInterpreter().adaptivePredict(_input, 312, _ctx)) { - case 1: { - _localctx = new AdditiveExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression); - setState(2756); - if (!(precpred(_ctx, 2))) - throw new FailedPredicateException(this, "precpred(_ctx, 2)"); - setState(2757); - match(ADD); - setState(2758); - multiplicativeExpression(0); - } - break; - case 2: { - _localctx = new AdditiveExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression); - setState(2759); - if (!(precpred(_ctx, 1))) - throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(2760); - match(SUB); - setState(2761); - multiplicativeExpression(0); - } - break; - } - } - } - setState(2766); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 313, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class MultiplicativeExpressionContext extends ParserRuleContext { - public UnaryExpressionContext unaryExpression() { - return getRuleContext(UnaryExpressionContext.class, 0); - } - - public MultiplicativeExpressionContext multiplicativeExpression() { - return getRuleContext(MultiplicativeExpressionContext.class, 0); - } - - public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_multiplicativeExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitMultiplicativeExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException { - return multiplicativeExpression(0); - } - - private MultiplicativeExpressionContext multiplicativeExpression(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, _parentState); - MultiplicativeExpressionContext _prevctx = _localctx; - int _startState = 452; - enterRecursionRule(_localctx, 452, RULE_multiplicativeExpression, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - { - setState(2768); - unaryExpression(); - } - _ctx.stop = _input.LT(-1); - setState(2781); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 315, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - if (_parseListeners != null) triggerExitRuleEvent(); - _prevctx = _localctx; - { - setState(2779); - switch (getInterpreter().adaptivePredict(_input, 314, _ctx)) { - case 1: { - _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); - setState(2770); - if (!(precpred(_ctx, 3))) - throw new FailedPredicateException(this, "precpred(_ctx, 3)"); - setState(2771); - match(MUL); - setState(2772); - unaryExpression(); - } - break; - case 2: { - _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); - setState(2773); - if (!(precpred(_ctx, 2))) - throw new FailedPredicateException(this, "precpred(_ctx, 2)"); - setState(2774); - match(DIV); - setState(2775); - unaryExpression(); - } - break; - case 3: { - _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); - setState(2776); - if (!(precpred(_ctx, 1))) - throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(2777); - match(MOD); - setState(2778); - unaryExpression(); - } - break; - } - } - } - setState(2783); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 315, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class UnaryExpressionContext extends ParserRuleContext { - public PreIncrementExpressionContext preIncrementExpression() { - return getRuleContext(PreIncrementExpressionContext.class, 0); - } - - public PreDecrementExpressionContext preDecrementExpression() { - return getRuleContext(PreDecrementExpressionContext.class, 0); - } - - public UnaryExpressionContext unaryExpression() { - return getRuleContext(UnaryExpressionContext.class, 0); - } - - public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() { - return getRuleContext(UnaryExpressionNotPlusMinusContext.class, 0); - } - - public UnaryExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unaryExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnaryExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnaryExpressionContext unaryExpression() throws RecognitionException { - UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState()); - enterRule(_localctx, 454, RULE_unaryExpression); - try { - setState(2791); - switch (_input.LA(1)) { - case INC: - enterOuterAlt(_localctx, 1); - { - setState(2784); - preIncrementExpression(); - } - break; - case DEC: - enterOuterAlt(_localctx, 2); - { - setState(2785); - preDecrementExpression(); - } - break; - case ADD: - enterOuterAlt(_localctx, 3); - { - setState(2786); - match(ADD); - setState(2787); - unaryExpression(); - } - break; - case SUB: - enterOuterAlt(_localctx, 4); - { - setState(2788); - match(SUB); - setState(2789); - unaryExpression(); - } - break; - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case NEW: - case SHORT: - case SUPER: - case THIS: - case VOID: - case IntegerLiteral: - case FloatingPointLiteral: - case BooleanLiteral: - case CharacterLiteral: - case StringLiteral: - case NullLiteral: - case LPAREN: - case BANG: - case TILDE: - case Identifier: - case AT: - enterOuterAlt(_localctx, 5); - { - setState(2790); - unaryExpressionNotPlusMinus(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PreIncrementExpressionContext extends ParserRuleContext { - public UnaryExpressionContext unaryExpression() { - return getRuleContext(UnaryExpressionContext.class, 0); - } - - public PreIncrementExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_preIncrementExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPreIncrementExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PreIncrementExpressionContext preIncrementExpression() throws RecognitionException { - PreIncrementExpressionContext _localctx = new PreIncrementExpressionContext(_ctx, getState()); - enterRule(_localctx, 456, RULE_preIncrementExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(2793); - match(INC); - setState(2794); - unaryExpression(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PreDecrementExpressionContext extends ParserRuleContext { - public UnaryExpressionContext unaryExpression() { - return getRuleContext(UnaryExpressionContext.class, 0); - } - - public PreDecrementExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_preDecrementExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPreDecrementExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PreDecrementExpressionContext preDecrementExpression() throws RecognitionException { - PreDecrementExpressionContext _localctx = new PreDecrementExpressionContext(_ctx, getState()); - enterRule(_localctx, 458, RULE_preDecrementExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(2796); - match(DEC); - setState(2797); - unaryExpression(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class UnaryExpressionNotPlusMinusContext extends ParserRuleContext { - public PostfixExpressionContext postfixExpression() { - return getRuleContext(PostfixExpressionContext.class, 0); - } - - public UnaryExpressionContext unaryExpression() { - return getRuleContext(UnaryExpressionContext.class, 0); - } - - public CastExpressionContext castExpression() { - return getRuleContext(CastExpressionContext.class, 0); - } - - public UnaryExpressionNotPlusMinusContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_unaryExpressionNotPlusMinus; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitUnaryExpressionNotPlusMinus(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() throws RecognitionException { - UnaryExpressionNotPlusMinusContext _localctx = new UnaryExpressionNotPlusMinusContext(_ctx, getState()); - enterRule(_localctx, 460, RULE_unaryExpressionNotPlusMinus); - try { - setState(2805); - switch (getInterpreter().adaptivePredict(_input, 317, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2799); - postfixExpression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2800); - match(TILDE); - setState(2801); - unaryExpression(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2802); - match(BANG); - setState(2803); - unaryExpression(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(2804); - castExpression(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PostfixExpressionContext extends ParserRuleContext { - public PrimaryContext primary() { - return getRuleContext(PrimaryContext.class, 0); - } - - public ExpressionNameContext expressionName() { - return getRuleContext(ExpressionNameContext.class, 0); - } - - public List<? extends PostIncrementExpression_lf_postfixExpressionContext> postIncrementExpression_lf_postfixExpression() { - return getRuleContexts(PostIncrementExpression_lf_postfixExpressionContext.class); - } - - public PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression(int i) { - return getRuleContext(PostIncrementExpression_lf_postfixExpressionContext.class, i); - } - - public List<? extends PostDecrementExpression_lf_postfixExpressionContext> postDecrementExpression_lf_postfixExpression() { - return getRuleContexts(PostDecrementExpression_lf_postfixExpressionContext.class); - } - - public PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression(int i) { - return getRuleContext(PostDecrementExpression_lf_postfixExpressionContext.class, i); - } - - public PostfixExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_postfixExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPostfixExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PostfixExpressionContext postfixExpression() throws RecognitionException { - PostfixExpressionContext _localctx = new PostfixExpressionContext(_ctx, getState()); - enterRule(_localctx, 462, RULE_postfixExpression); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2809); - switch (getInterpreter().adaptivePredict(_input, 318, _ctx)) { - case 1: { - setState(2807); - primary(); - } - break; - case 2: { - setState(2808); - expressionName(); - } - break; - } - setState(2815); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 320, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - setState(2813); - switch (_input.LA(1)) { - case INC: { - setState(2811); - postIncrementExpression_lf_postfixExpression(); - } - break; - case DEC: { - setState(2812); - postDecrementExpression_lf_postfixExpression(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(2817); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 320, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PostIncrementExpressionContext extends ParserRuleContext { - public PostfixExpressionContext postfixExpression() { - return getRuleContext(PostfixExpressionContext.class, 0); - } - - public PostIncrementExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_postIncrementExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPostIncrementExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PostIncrementExpressionContext postIncrementExpression() throws RecognitionException { - PostIncrementExpressionContext _localctx = new PostIncrementExpressionContext(_ctx, getState()); - enterRule(_localctx, 464, RULE_postIncrementExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(2818); - postfixExpression(); - setState(2819); - match(INC); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PostIncrementExpression_lf_postfixExpressionContext extends ParserRuleContext { - public PostIncrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_postIncrementExpression_lf_postfixExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPostIncrementExpression_lf_postfixExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression() throws RecognitionException { - PostIncrementExpression_lf_postfixExpressionContext _localctx = new PostIncrementExpression_lf_postfixExpressionContext(_ctx, getState()); - enterRule(_localctx, 466, RULE_postIncrementExpression_lf_postfixExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(2821); - match(INC); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PostDecrementExpressionContext extends ParserRuleContext { - public PostfixExpressionContext postfixExpression() { - return getRuleContext(PostfixExpressionContext.class, 0); - } - - public PostDecrementExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_postDecrementExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPostDecrementExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PostDecrementExpressionContext postDecrementExpression() throws RecognitionException { - PostDecrementExpressionContext _localctx = new PostDecrementExpressionContext(_ctx, getState()); - enterRule(_localctx, 468, RULE_postDecrementExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(2823); - postfixExpression(); - setState(2824); - match(DEC); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PostDecrementExpression_lf_postfixExpressionContext extends ParserRuleContext { - public PostDecrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_postDecrementExpression_lf_postfixExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitPostDecrementExpression_lf_postfixExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression() throws RecognitionException { - PostDecrementExpression_lf_postfixExpressionContext _localctx = new PostDecrementExpression_lf_postfixExpressionContext(_ctx, getState()); - enterRule(_localctx, 470, RULE_postDecrementExpression_lf_postfixExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(2826); - match(DEC); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class CastExpressionContext extends ParserRuleContext { - public PrimitiveTypeContext primitiveType() { - return getRuleContext(PrimitiveTypeContext.class, 0); - } - - public UnaryExpressionContext unaryExpression() { - return getRuleContext(UnaryExpressionContext.class, 0); - } - - public ReferenceTypeContext referenceType() { - return getRuleContext(ReferenceTypeContext.class, 0); - } - - public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() { - return getRuleContext(UnaryExpressionNotPlusMinusContext.class, 0); - } - - public List<? extends AdditionalBoundContext> additionalBound() { - return getRuleContexts(AdditionalBoundContext.class); - } - - public AdditionalBoundContext additionalBound(int i) { - return getRuleContext(AdditionalBoundContext.class, i); - } - - public LambdaExpressionContext lambdaExpression() { - return getRuleContext(LambdaExpressionContext.class, 0); - } - - public CastExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_castExpression; - } - - @Override - public <Result> Result accept(ParseTreeVisitor<? extends Result> visitor) { - if (visitor instanceof Java8Visitor<?>) - return ((Java8Visitor<? extends Result>) visitor).visitCastExpression(this); - else return visitor.visitChildren(this); - } - } - - @RuleVersion(0) - public final CastExpressionContext castExpression() throws RecognitionException { - CastExpressionContext _localctx = new CastExpressionContext(_ctx, getState()); - enterRule(_localctx, 472, RULE_castExpression); - int _la; - try { - setState(2855); - switch (getInterpreter().adaptivePredict(_input, 323, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2828); - match(LPAREN); - setState(2829); - primitiveType(); - setState(2830); - match(RPAREN); - setState(2831); - unaryExpression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2833); - match(LPAREN); - setState(2834); - referenceType(); - setState(2838); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == BITAND) { - { - { - setState(2835); - additionalBound(); - } - } - setState(2840); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2841); - match(RPAREN); - setState(2842); - unaryExpressionNotPlusMinus(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2844); - match(LPAREN); - setState(2845); - referenceType(); - setState(2849); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == BITAND) { - { - { - setState(2846); - additionalBound(); - } - } - setState(2851); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2852); - match(RPAREN); - setState(2853); - lambdaExpression(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { - switch (ruleIndex) { - case 26: - return packageName_sempred((PackageNameContext) _localctx, predIndex); - case 28: - return packageOrTypeName_sempred((PackageOrTypeNameContext) _localctx, predIndex); - case 31: - return ambiguousName_sempred((AmbiguousNameContext) _localctx, predIndex); - case 217: - return conditionalOrExpression_sempred((ConditionalOrExpressionContext) _localctx, predIndex); - case 218: - return conditionalAndExpression_sempred((ConditionalAndExpressionContext) _localctx, predIndex); - case 219: - return inclusiveOrExpression_sempred((InclusiveOrExpressionContext) _localctx, predIndex); - case 220: - return exclusiveOrExpression_sempred((ExclusiveOrExpressionContext) _localctx, predIndex); - case 221: - return andExpression_sempred((AndExpressionContext) _localctx, predIndex); - case 222: - return equalityExpression_sempred((EqualityExpressionContext) _localctx, predIndex); - case 223: - return relationalExpression_sempred((RelationalExpressionContext) _localctx, predIndex); - case 224: - return shiftExpression_sempred((ShiftExpressionContext) _localctx, predIndex); - case 225: - return additiveExpression_sempred((AdditiveExpressionContext) _localctx, predIndex); - case 226: - return multiplicativeExpression_sempred((MultiplicativeExpressionContext) _localctx, predIndex); - } - return true; - } - - private boolean packageName_sempred(PackageNameContext _localctx, int predIndex) { - switch (predIndex) { - case 0: - return precpred(_ctx, 1); - } - return true; - } - - private boolean packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, int predIndex) { - switch (predIndex) { - case 1: - return precpred(_ctx, 1); - } - return true; - } - - private boolean ambiguousName_sempred(AmbiguousNameContext _localctx, int predIndex) { - switch (predIndex) { - case 2: - return precpred(_ctx, 1); - } - return true; - } - - private boolean conditionalOrExpression_sempred(ConditionalOrExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 3: - return precpred(_ctx, 1); - } - return true; - } - - private boolean conditionalAndExpression_sempred(ConditionalAndExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 4: - return precpred(_ctx, 1); - } - return true; - } - - private boolean inclusiveOrExpression_sempred(InclusiveOrExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 5: - return precpred(_ctx, 1); - } - return true; - } - - private boolean exclusiveOrExpression_sempred(ExclusiveOrExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 6: - return precpred(_ctx, 1); - } - return true; - } - - private boolean andExpression_sempred(AndExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 7: - return precpred(_ctx, 1); - } - return true; - } - - private boolean equalityExpression_sempred(EqualityExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 8: - return precpred(_ctx, 2); - case 9: - return precpred(_ctx, 1); - } - return true; - } - - private boolean relationalExpression_sempred(RelationalExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 10: - return precpred(_ctx, 5); - case 11: - return precpred(_ctx, 4); - case 12: - return precpred(_ctx, 3); - case 13: - return precpred(_ctx, 2); - case 14: - return precpred(_ctx, 1); - } - return true; - } - - private boolean shiftExpression_sempred(ShiftExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 15: - return precpred(_ctx, 3); - case 16: - return precpred(_ctx, 2); - case 17: - return precpred(_ctx, 1); - } - return true; - } - - private boolean additiveExpression_sempred(AdditiveExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 18: - return precpred(_ctx, 2); - case 19: - return precpred(_ctx, 1); - } - return true; - } - - private boolean multiplicativeExpression_sempred(MultiplicativeExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 20: - return precpred(_ctx, 3); - case 21: - return precpred(_ctx, 2); - case 22: - return precpred(_ctx, 1); - } - return true; - } - - private static final int _serializedATNSegments = 2; - private static final String _serializedATNSegment0 = - "\3\uaf6f\u8320\u479d\ub75c\u4880\u1605\u191c\uab37\3m\u0b2c\4\2\t\2\4" + - "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t" + - "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22" + - "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31" + - "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!" + - "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4" + - ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t" + - "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t=" + - "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I" + - "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT" + - "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4" + - "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t" + - "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4" + - "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080" + - "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085" + - "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089" + - "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e" + - "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092" + - "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097" + - "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b" + - "\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0" + - "\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4" + - "\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9" + - "\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad" + - "\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2" + - "\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6" + - "\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb" + - "\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf" + - "\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4" + - "\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8" + - "\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd" + - "\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1\t\u00d1" + - "\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4\4\u00d5\t\u00d5\4\u00d6" + - "\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da" + - "\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df" + - "\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2\t\u00e2\4\u00e3\t\u00e3" + - "\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8" + - "\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec" + - "\4\u00ed\t\u00ed\4\u00ee\t\u00ee\3\2\3\2\3\3\3\3\5\3\u01e1\n\3\3\4\7\4" + - "\u01e4\n\4\f\4\16\4\u01e7\13\4\3\4\3\4\7\4\u01eb\n\4\f\4\16\4\u01ee\13" + - "\4\3\4\5\4\u01f1\n\4\3\5\3\5\5\5\u01f5\n\5\3\6\3\6\3\7\3\7\3\b\3\b\3\b" + - "\5\b\u01fe\n\b\3\t\3\t\5\t\u0202\n\t\3\t\3\t\7\t\u0206\n\t\f\t\16\t\u0209" + - "\13\t\3\n\7\n\u020c\n\n\f\n\16\n\u020f\13\n\3\n\3\n\5\n\u0213\n\n\3\n" + - "\3\n\3\n\7\n\u0218\n\n\f\n\16\n\u021b\13\n\3\n\3\n\5\n\u021f\n\n\5\n\u0221" + - "\n\n\3\13\3\13\7\13\u0225\n\13\f\13\16\13\u0228\13\13\3\13\3\13\5\13\u022c" + - "\n\13\3\f\7\f\u022f\n\f\f\f\16\f\u0232\13\f\3\f\3\f\5\f\u0236\n\f\3\r" + - "\3\r\3\16\3\16\3\17\3\17\3\20\7\20\u023f\n\20\f\20\16\20\u0242\13\20\3" + - "\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u024f\n\21" + - "\3\22\7\22\u0252\n\22\f\22\16\22\u0255\13\22\3\22\3\22\3\22\7\22\u025a" + - "\n\22\f\22\16\22\u025d\13\22\3\22\3\22\7\22\u0261\n\22\f\22\16\22\u0264" + - "\13\22\3\23\7\23\u0267\n\23\f\23\16\23\u026a\13\23\3\23\3\23\5\23\u026e" + - "\n\23\3\24\3\24\3\25\3\25\3\25\3\25\3\25\7\25\u0277\n\25\f\25\16\25\u027a" + - "\13\25\5\25\u027c\n\25\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3\30\3\30\3" + - "\30\7\30\u0288\n\30\f\30\16\30\u028b\13\30\3\31\3\31\5\31\u028f\n\31\3" + - "\32\7\32\u0292\n\32\f\32\16\32\u0295\13\32\3\32\3\32\5\32\u0299\n\32\3" + - "\33\3\33\3\33\3\33\5\33\u029f\n\33\3\34\3\34\3\34\3\34\3\34\3\34\7\34" + - "\u02a7\n\34\f\34\16\34\u02aa\13\34\3\35\3\35\3\35\3\35\3\35\5\35\u02b1" + - "\n\35\3\36\3\36\3\36\3\36\3\36\3\36\7\36\u02b9\n\36\f\36\16\36\u02bc\13" + - "\36\3\37\3\37\3\37\3\37\3\37\5\37\u02c3\n\37\3 \3 \3!\3!\3!\3!\3!\3!\7" + - "!\u02cd\n!\f!\16!\u02d0\13!\3\"\5\"\u02d3\n\"\3\"\7\"\u02d6\n\"\f\"\16" + - "\"\u02d9\13\"\3\"\7\"\u02dc\n\"\f\"\16\"\u02df\13\"\3\"\3\"\3#\7#\u02e4" + - "\n#\f#\16#\u02e7\13#\3#\3#\3#\3#\7#\u02ed\n#\f#\16#\u02f0\13#\3#\3#\3" + - "$\3$\3%\3%\3%\3%\5%\u02fa\n%\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3(\3" + - "(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3)\3)\3*\3*\3*\5*\u0317\n*\3+\3+\5+\u031b" + - "\n+\3,\7,\u031e\n,\f,\16,\u0321\13,\3,\3,\3,\5,\u0326\n,\3,\5,\u0329\n" + - ",\3,\5,\u032c\n,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3-\5-\u0338\n-\3.\3.\3.\3" + - ".\3/\3/\3/\7/\u0341\n/\f/\16/\u0344\13/\3\60\3\60\3\60\3\61\3\61\3\61" + - "\3\62\3\62\3\62\7\62\u034f\n\62\f\62\16\62\u0352\13\62\3\63\3\63\7\63" + - "\u0356\n\63\f\63\16\63\u0359\13\63\3\63\3\63\3\64\3\64\3\64\3\64\5\64" + - "\u0361\n\64\3\65\3\65\3\65\3\65\3\65\5\65\u0368\n\65\3\66\7\66\u036b\n" + - "\66\f\66\16\66\u036e\13\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67" + - "\3\67\3\67\3\67\5\67\u037c\n\67\38\38\38\78\u0381\n8\f8\168\u0384\138" + - "\39\39\39\59\u0389\n9\3:\3:\5:\u038d\n:\3;\3;\5;\u0391\n;\3<\3<\5<\u0395" + - "\n<\3=\3=\5=\u0399\n=\3>\3>\3>\5>\u039e\n>\3?\3?\5?\u03a2\n?\3?\3?\7?" + - "\u03a6\n?\f?\16?\u03a9\13?\3@\3@\5@\u03ad\n@\3@\3@\3@\7@\u03b2\n@\f@\16" + - "@\u03b5\13@\3@\3@\5@\u03b9\n@\5@\u03bb\n@\3A\3A\7A\u03bf\nA\fA\16A\u03c2" + - "\13A\3A\3A\5A\u03c6\nA\3B\3B\5B\u03ca\nB\3C\3C\3D\3D\3E\3E\3F\3F\3G\3" + - "G\3G\3G\3G\3G\3G\3G\3G\5G\u03dd\nG\3H\7H\u03e0\nH\fH\16H\u03e3\13H\3H" + - "\3H\3H\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\5I\u03f2\nI\3J\3J\3J\5J\u03f7\nJ" + - "\3J\3J\7J\u03fb\nJ\fJ\16J\u03fe\13J\3J\3J\3J\5J\u0403\nJ\5J\u0405\nJ\3" + - "K\3K\5K\u0409\nK\3L\3L\3L\5L\u040e\nL\3L\3L\5L\u0412\nL\3M\3M\3M\3M\3" + - "M\5M\u0419\nM\3N\3N\3N\7N\u041e\nN\fN\16N\u0421\13N\3N\3N\3N\7N\u0426" + - "\nN\fN\16N\u0429\13N\5N\u042b\nN\3O\7O\u042e\nO\fO\16O\u0431\13O\3O\3" + - "O\3O\3P\3P\5P\u0438\nP\3Q\7Q\u043b\nQ\fQ\16Q\u043e\13Q\3Q\3Q\7Q\u0442" + - "\nQ\fQ\16Q\u0445\13Q\3Q\3Q\3Q\3Q\5Q\u044b\nQ\3R\7R\u044e\nR\fR\16R\u0451" + - "\13R\3R\3R\3R\5R\u0456\nR\3R\3R\3S\3S\3S\3T\3T\3T\7T\u0460\nT\fT\16T\u0463" + - "\13T\3U\3U\5U\u0467\nU\3V\3V\5V\u046b\nV\3W\3W\3X\3X\3X\3Y\7Y\u0473\n" + - "Y\fY\16Y\u0476\13Y\3Y\3Y\5Y\u047a\nY\3Y\3Y\3Z\3Z\3Z\3Z\5Z\u0482\nZ\3[" + - "\5[\u0485\n[\3[\3[\3[\5[\u048a\n[\3[\3[\3\\\3\\\3]\3]\5]\u0492\n]\3]\5" + - "]\u0495\n]\3]\3]\3^\5^\u049a\n^\3^\3^\3^\5^\u049f\n^\3^\3^\3^\5^\u04a4" + - "\n^\3^\3^\3^\5^\u04a9\n^\3^\3^\3^\3^\3^\5^\u04b0\n^\3^\3^\3^\5^\u04b5" + - "\n^\3^\3^\3^\3^\3^\3^\5^\u04bd\n^\3^\3^\3^\5^\u04c2\n^\3^\3^\3^\5^\u04c7" + - "\n^\3_\7_\u04ca\n_\f_\16_\u04cd\13_\3_\3_\3_\5_\u04d2\n_\3_\3_\3`\3`\5" + - "`\u04d8\n`\3`\5`\u04db\n`\3`\5`\u04de\n`\3`\3`\3a\3a\3a\7a\u04e5\na\f" + - "a\16a\u04e8\13a\3b\7b\u04eb\nb\fb\16b\u04ee\13b\3b\3b\3b\5b\u04f3\nb\3" + - "b\5b\u04f6\nb\3b\5b\u04f9\nb\3c\3c\3d\3d\7d\u04ff\nd\fd\16d\u0502\13d" + - "\3e\3e\5e\u0506\ne\3f\7f\u0509\nf\ff\16f\u050c\13f\3f\3f\3f\5f\u0511\n" + - "f\3f\5f\u0514\nf\3f\3f\3g\3g\3g\3g\3g\3g\3g\5g\u051f\ng\3h\3h\3h\3i\3" + - "i\7i\u0526\ni\fi\16i\u0529\13i\3i\3i\3j\3j\3j\3j\3j\5j\u0532\nj\3k\7k" + - "\u0535\nk\fk\16k\u0538\13k\3k\3k\3k\3k\3l\3l\3l\3l\5l\u0542\nl\3m\7m\u0545" + - "\nm\fm\16m\u0548\13m\3m\3m\3m\3n\3n\3n\3n\3n\3n\5n\u0553\nn\3o\7o\u0556" + - "\no\fo\16o\u0559\13o\3o\3o\3o\3o\3o\3p\3p\7p\u0562\np\fp\16p\u0565\13" + - "p\3p\3p\3q\3q\3q\3q\3q\5q\u056e\nq\3r\7r\u0571\nr\fr\16r\u0574\13r\3r" + - "\3r\3r\3r\3r\5r\u057b\nr\3r\5r\u057e\nr\3r\3r\3s\3s\3s\5s\u0585\ns\3t" + - "\3t\3t\3u\3u\3u\5u\u058d\nu\3v\3v\3v\3v\5v\u0593\nv\3v\3v\3w\3w\3w\7w" + - "\u059a\nw\fw\16w\u059d\13w\3x\3x\3x\3x\3y\3y\3y\5y\u05a6\ny\3z\3z\5z\u05aa" + - "\nz\3z\5z\u05ad\nz\3z\3z\3{\3{\3{\7{\u05b4\n{\f{\16{\u05b7\13{\3|\3|\3" + - "|\3}\3}\3}\3}\3}\3}\3~\3~\5~\u05c4\n~\3~\5~\u05c7\n~\3~\3~\3\177\3\177" + - "\3\177\7\177\u05ce\n\177\f\177\16\177\u05d1\13\177\3\u0080\3\u0080\5\u0080" + - "\u05d5\n\u0080\3\u0080\3\u0080\3\u0081\3\u0081\7\u0081\u05db\n\u0081\f" + - "\u0081\16\u0081\u05de\13\u0081\3\u0082\3\u0082\3\u0082\5\u0082\u05e3\n" + - "\u0082\3\u0083\3\u0083\3\u0083\3\u0084\7\u0084\u05e9\n\u0084\f\u0084\16" + - "\u0084\u05ec\13\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085" + - "\3\u0085\3\u0085\3\u0085\5\u0085\u05f7\n\u0085\3\u0086\3\u0086\3\u0086" + - "\3\u0086\3\u0086\5\u0086\u05fe\n\u0086\3\u0087\3\u0087\3\u0087\3\u0087" + - "\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\5\u0087" + - "\u060c\n\u0087\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\3\u0089\3\u008a" + - "\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008c\3\u008c\3\u008c" + - "\3\u008c\3\u008c\3\u008c\3\u008c\5\u008c\u0622\n\u008c\3\u008d\3\u008d" + - "\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e" + - "\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f" + - "\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090" + - "\3\u0090\3\u0090\3\u0090\5\u0090\u0644\n\u0090\3\u0091\3\u0091\3\u0091" + - "\3\u0091\3\u0091\3\u0091\3\u0092\3\u0092\7\u0092\u064e\n\u0092\f\u0092" + - "\16\u0092\u0651\13\u0092\3\u0092\7\u0092\u0654\n\u0092\f\u0092\16\u0092" + - "\u0657\13\u0092\3\u0092\3\u0092\3\u0093\3\u0093\3\u0093\3\u0094\3\u0094" + - "\7\u0094\u0660\n\u0094\f\u0094\16\u0094\u0663\13\u0094\3\u0095\3\u0095" + - "\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\5\u0095" + - "\u066f\n\u0095\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097" + - "\3\u0097\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099" + - "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u009a\3\u009a\5\u009a" + - "\u0689\n\u009a\3\u009b\3\u009b\5\u009b\u068d\n\u009b\3\u009c\3\u009c\3" + - "\u009c\5\u009c\u0692\n\u009c\3\u009c\3\u009c\5\u009c\u0696\n\u009c\3\u009c" + - "\3\u009c\5\u009c\u069a\n\u009c\3\u009c\3\u009c\3\u009c\3\u009d\3\u009d" + - "\3\u009d\5\u009d\u06a2\n\u009d\3\u009d\3\u009d\5\u009d\u06a6\n\u009d\3" + - "\u009d\3\u009d\5\u009d\u06aa\n\u009d\3\u009d\3\u009d\3\u009d\3\u009e\3" + - "\u009e\5\u009e\u06b1\n\u009e\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\7" + - "\u00a0\u06b8\n\u00a0\f\u00a0\16\u00a0\u06bb\13\u00a0\3\u00a1\3\u00a1\3" + - "\u00a1\7\u00a1\u06c0\n\u00a1\f\u00a1\16\u00a1\u06c3\13\u00a1\3\u00a1\3" + - "\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2" + - "\7\u00a2\u06cf\n\u00a2\f\u00a2\16\u00a2\u06d2\13\u00a2\3\u00a2\3\u00a2" + - "\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3\5\u00a3\u06dd" + - "\n\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\5\u00a4\u06e3\n\u00a4\3\u00a4" + - "\3\u00a4\3\u00a5\3\u00a5\5\u00a5\u06e9\n\u00a5\3\u00a5\3\u00a5\3\u00a6" + - "\3\u00a6\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7" + - "\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u06fe" + - "\n\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0703\n\u00a8\3\u00a9\3\u00a9" + - "\7\u00a9\u0707\n\u00a9\f\u00a9\16\u00a9\u070a\13\u00a9\3\u00aa\3\u00aa" + - "\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\7\u00ab\u0713\n\u00ab\f\u00ab" + - "\16\u00ab\u0716\13\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac\3\u00ac" + - "\7\u00ac\u071e\n\u00ac\f\u00ac\16\u00ac\u0721\13\u00ac\3\u00ad\3\u00ad" + - "\3\u00ad\3\u00ae\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u072a\n\u00ae\3\u00ae" + - "\5\u00ae\u072d\n\u00ae\3\u00af\3\u00af\3\u00af\5\u00af\u0732\n\u00af\3" + - "\u00af\3\u00af\3\u00b0\3\u00b0\3\u00b0\7\u00b0\u0739\n\u00b0\f\u00b0\16" + - "\u00b0\u073c\13\u00b0\3\u00b1\7\u00b1\u073f\n\u00b1\f\u00b1\16\u00b1\u0742" + - "\13\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2\5\u00b2" + - "\u074b\n\u00b2\3\u00b2\7\u00b2\u074e\n\u00b2\f\u00b2\16\u00b2\u0751\13" + - "\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\7\u00b3\u0757\n\u00b3\f\u00b3\16" + - "\u00b3\u075a\13\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3" + - "\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3" + - "\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\5\u00b3\u0770\n\u00b3\3\u00b4" + - "\3\u00b4\3\u00b5\3\u00b5\3\u00b5\3\u00b5\7\u00b5\u0778\n\u00b5\f\u00b5" + - "\16\u00b5\u077b\13\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5" + - "\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5" + - "\3\u00b5\3\u00b5\3\u00b5\3\u00b5\5\u00b5\u0790\n\u00b5\3\u00b6\3\u00b6" + - "\3\u00b6\3\u00b6\3\u00b6\5\u00b6\u0797\n\u00b6\3\u00b7\3\u00b7\3\u00b8" + - "\3\u00b8\3\u00b8\3\u00b8\5\u00b8\u079f\n\u00b8\3\u00b9\3\u00b9\3\u00b9" + - "\3\u00b9\7\u00b9\u07a5\n\u00b9\f\u00b9\16\u00b9\u07a8\13\u00b9\3\u00b9" + - "\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\7\u00b9\u07b0\n\u00b9\f\u00b9" + - "\16\u00b9\u07b3\13\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9" + - "\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9" + - "\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\5\u00b9\u07c9\n\u00b9\3\u00ba" + - "\3\u00ba\3\u00bb\3\u00bb\3\u00bb\3\u00bb\7\u00bb\u07d1\n\u00bb\f\u00bb" + - "\16\u00bb\u07d4\13\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb" + - "\7\u00bb\u07dc\n\u00bb\f\u00bb\16\u00bb\u07df\13\u00bb\3\u00bb\3\u00bb" + - "\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb" + - "\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\5\u00bb" + - "\u07f4\n\u00bb\3\u00bc\3\u00bc\5\u00bc\u07f8\n\u00bc\3\u00bc\7\u00bc\u07fb" + - "\n\u00bc\f\u00bc\16\u00bc\u07fe\13\u00bc\3\u00bc\3\u00bc\3\u00bc\7\u00bc" + - "\u0803\n\u00bc\f\u00bc\16\u00bc\u0806\13\u00bc\3\u00bc\7\u00bc\u0809\n" + - "\u00bc\f\u00bc\16\u00bc\u080c\13\u00bc\3\u00bc\5\u00bc\u080f\n\u00bc\3" + - "\u00bc\3\u00bc\5\u00bc\u0813\n\u00bc\3\u00bc\3\u00bc\5\u00bc\u0817\n\u00bc" + - "\3\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u081d\n\u00bc\3\u00bc\7\u00bc" + - "\u0820\n\u00bc\f\u00bc\16\u00bc\u0823\13\u00bc\3\u00bc\3\u00bc\5\u00bc" + - "\u0827\n\u00bc\3\u00bc\3\u00bc\5\u00bc\u082b\n\u00bc\3\u00bc\3\u00bc\5" + - "\u00bc\u082f\n\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u0835\n\u00bc" + - "\3\u00bc\7\u00bc\u0838\n\u00bc\f\u00bc\16\u00bc\u083b\13\u00bc\3\u00bc" + - "\3\u00bc\5\u00bc\u083f\n\u00bc\3\u00bc\3\u00bc\5\u00bc\u0843\n\u00bc\3" + - "\u00bc\3\u00bc\5\u00bc\u0847\n\u00bc\5\u00bc\u0849\n\u00bc\3\u00bd\3\u00bd" + - "\3\u00bd\5\u00bd\u084e\n\u00bd\3\u00bd\7\u00bd\u0851\n\u00bd\f\u00bd\16" + - "\u00bd\u0854\13\u00bd\3\u00bd\3\u00bd\5\u00bd\u0858\n\u00bd\3\u00bd\3" + - "\u00bd\5\u00bd\u085c\n\u00bd\3\u00bd\3\u00bd\5\u00bd\u0860\n\u00bd\3\u00be" + - "\3\u00be\5\u00be\u0864\n\u00be\3\u00be\7\u00be\u0867\n\u00be\f\u00be\16" + - "\u00be\u086a\13\u00be\3\u00be\3\u00be\3\u00be\7\u00be\u086f\n\u00be\f" + - "\u00be\16\u00be\u0872\13\u00be\3\u00be\7\u00be\u0875\n\u00be\f\u00be\16" + - "\u00be\u0878\13\u00be\3\u00be\5\u00be\u087b\n\u00be\3\u00be\3\u00be\5" + - "\u00be\u087f\n\u00be\3\u00be\3\u00be\5\u00be\u0883\n\u00be\3\u00be\3\u00be" + - "\3\u00be\3\u00be\5\u00be\u0889\n\u00be\3\u00be\7\u00be\u088c\n\u00be\f" + - "\u00be\16\u00be\u088f\13\u00be\3\u00be\3\u00be\5\u00be\u0893\n\u00be\3" + - "\u00be\3\u00be\5\u00be\u0897\n\u00be\3\u00be\3\u00be\5\u00be\u089b\n\u00be" + - "\5\u00be\u089d\n\u00be\3\u00bf\3\u00bf\3\u00bf\5\u00bf\u08a2\n\u00bf\3" + - "\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0" + - "\3\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0\u08b1\n\u00c0\3\u00c1\3\u00c1" + - "\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2" + - "\3\u00c2\5\u00c2\u08bf\n\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3" + - "\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\5\u00c3\u08cb\n\u00c3\3\u00c3" + - "\3\u00c3\3\u00c3\3\u00c3\3\u00c3\7\u00c3\u08d2\n\u00c3\f\u00c3\16\u00c3" + - "\u08d5\13\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4" + - "\3\u00c4\3\u00c4\3\u00c4\7\u00c4\u08e1\n\u00c4\f\u00c4\16\u00c4\u08e4" + - "\13\u00c4\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5" + - "\3\u00c5\3\u00c5\5\u00c5\u08f0\n\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5" + - "\3\u00c5\7\u00c5\u08f7\n\u00c5\f\u00c5\16\u00c5\u08fa\13\u00c5\3\u00c6" + - "\3\u00c6\3\u00c6\5\u00c6\u08ff\n\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6" + - "\3\u00c6\5\u00c6\u0906\n\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u090b\n" + - "\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0912\n\u00c6\3" + - "\u00c6\3\u00c6\3\u00c6\5\u00c6\u0917\n\u00c6\3\u00c6\3\u00c6\3\u00c6\3" + - "\u00c6\3\u00c6\5\u00c6\u091e\n\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0923" + - "\n\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u092a\n\u00c6" + - "\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u092f\n\u00c6\3\u00c6\3\u00c6\3\u00c6" + - "\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0937\n\u00c6\3\u00c6\3\u00c6\3\u00c6" + - "\5\u00c6\u093c\n\u00c6\3\u00c6\3\u00c6\5\u00c6\u0940\n\u00c6\3\u00c7\3" + - "\u00c7\5\u00c7\u0944\n\u00c7\3\u00c7\3\u00c7\3\u00c7\5\u00c7\u0949\n\u00c7" + - "\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0950\n\u00c8\3\u00c8" + - "\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0957\n\u00c8\3\u00c8\3\u00c8" + - "\3\u00c8\5\u00c8\u095c\n\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8" + - "\5\u00c8\u0963\n\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0968\n\u00c8\3" + - "\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u096f\n\u00c8\3\u00c8\3" + - "\u00c8\3\u00c8\5\u00c8\u0974\n\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3" + - "\u00c8\3\u00c8\5\u00c8\u097c\n\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0981" + - "\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u0985\n\u00c8\3\u00c9\3\u00c9\3\u00c9" + - "\7\u00c9\u098a\n\u00c9\f\u00c9\16\u00c9\u098d\13\u00c9\3\u00ca\3\u00ca" + - "\3\u00ca\5\u00ca\u0992\n\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca" + - "\5\u00ca\u0999\n\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca" + - "\u09a0\n\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09a7\n" + - "\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09af\n" + - "\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09b6\n\u00ca\3" + - "\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09be\n\u00ca\3" + - "\u00cb\3\u00cb\5\u00cb\u09c2\n\u00cb\3\u00cb\3\u00cb\3\u00cc\3\u00cc\3" + - "\u00cc\5\u00cc\u09c9\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5" + - "\u00cc\u09d0\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09d7" + - "\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09df" + - "\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09e6\n\u00cc" + - "\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09ee\n\u00cc" + - "\3\u00cd\3\u00cd\3\u00cd\3\u00cd\5\u00cd\u09f4\n\u00cd\3\u00cd\3\u00cd" + - "\3\u00cd\3\u00cd\5\u00cd\u09fa\n\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd" + - "\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\5\u00cd\u0a06\n\u00cd" + - "\3\u00ce\3\u00ce\7\u00ce\u0a0a\n\u00ce\f\u00ce\16\u00ce\u0a0d\13\u00ce" + - "\3\u00cf\7\u00cf\u0a10\n\u00cf\f\u00cf\16\u00cf\u0a13\13\u00cf\3\u00cf" + - "\3\u00cf\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d1\3\u00d1\5\u00d1\u0a1d" + - "\n\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d3\3\u00d3\3\u00d3\5\u00d3" + - "\u0a26\n\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\5\u00d3\u0a2d\n" + - "\u00d3\3\u00d4\3\u00d4\3\u00d4\7\u00d4\u0a32\n\u00d4\f\u00d4\16\u00d4" + - "\u0a35\13\u00d4\3\u00d5\3\u00d5\5\u00d5\u0a39\n\u00d5\3\u00d6\3\u00d6" + - "\5\u00d6\u0a3d\n\u00d6\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d8\3\u00d8" + - "\3\u00d8\5\u00d8\u0a46\n\u00d8\3\u00d9\3\u00d9\3\u00da\3\u00da\3\u00da" + - "\3\u00da\3\u00da\3\u00da\3\u00da\5\u00da\u0a51\n\u00da\3\u00db\3\u00db" + - "\3\u00db\3\u00db\3\u00db\3\u00db\7\u00db\u0a59\n\u00db\f\u00db\16\u00db" + - "\u0a5c\13\u00db\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\7\u00dc" + - "\u0a64\n\u00dc\f\u00dc\16\u00dc\u0a67\13\u00dc\3\u00dd\3\u00dd\3\u00dd" + - "\3\u00dd\3\u00dd\3\u00dd\7\u00dd\u0a6f\n\u00dd\f\u00dd\16\u00dd\u0a72" + - "\13\u00dd\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\7\u00de\u0a7a" + - "\n\u00de\f\u00de\16\u00de\u0a7d\13\u00de\3\u00df\3\u00df\3\u00df\3\u00df" + - "\3\u00df\3\u00df\7\u00df\u0a85\n\u00df\f\u00df\16\u00df\u0a88\13\u00df" + - "\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0" + - "\7\u00e0\u0a93\n\u00e0\f\u00e0\16\u00e0\u0a96\13\u00e0\3\u00e1\3\u00e1" + - "\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1" + - "\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\7\u00e1\u0aaa" + - "\n\u00e1\f\u00e1\16\u00e1\u0aad\13\u00e1\3\u00e2\3\u00e2\3\u00e2\3\u00e2" + - "\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2" + - "\3\u00e2\3\u00e2\3\u00e2\7\u00e2\u0abf\n\u00e2\f\u00e2\16\u00e2\u0ac2" + - "\13\u00e2\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3" + - "\3\u00e3\7\u00e3\u0acd\n\u00e3\f\u00e3\16\u00e3\u0ad0\13\u00e3\3\u00e4" + - "\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4" + - "\3\u00e4\3\u00e4\7\u00e4\u0ade\n\u00e4\f\u00e4\16\u00e4\u0ae1\13\u00e4" + - "\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\5\u00e5\u0aea" + - "\n\u00e5\3\u00e6\3\u00e6\3\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e8\3\u00e8" + - "\3\u00e8\3\u00e8\3\u00e8\3\u00e8\5\u00e8\u0af8\n\u00e8\3\u00e9\3\u00e9" + - "\5\u00e9\u0afc\n\u00e9\3\u00e9\3\u00e9\7\u00e9\u0b00\n\u00e9\f\u00e9\16" + - "\u00e9\u0b03\13\u00e9\3\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00ec" + - "\3\u00ec\3\u00ec\3\u00ed\3\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee" + - "\3\u00ee\3\u00ee\3\u00ee\7\u00ee\u0b17\n\u00ee\f\u00ee\16\u00ee\u0b1a" + - "\13\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\7\u00ee\u0b22" + - "\n\u00ee\f\u00ee\16\u00ee\u0b25\13\u00ee\3\u00ee\3\u00ee\3\u00ee\5\u00ee" + - "\u0b2a\n\u00ee\3\u00ee\2\2\17\66:@\u01b4\u01b6\u01b8\u01ba\u01bc\u01be" + - "\u01c0\u01c2\u01c4\u01c6\u00ef\2\2\4\2\6\2\b\2\n\2\f\2\16\2\20\2\22\2" + - "\24\2\26\2\30\2\32\2\34\2\36\2 \2\"\2$\2&\2(\2*\2,\2.\2\60\2\62\2\64\2" + - "\66\28\2:\2<\2>\2@\2B\2D\2F\2H\2J\2L\2N\2P\2R\2T\2V\2X\2Z\2\\\2^\2`\2" + - "b\2d\2f\2h\2j\2l\2n\2p\2r\2t\2v\2x\2z\2|\2~\2\u0080\2\u0082\2\u0084\2" + - "\u0086\2\u0088\2\u008a\2\u008c\2\u008e\2\u0090\2\u0092\2\u0094\2\u0096" + - "\2\u0098\2\u009a\2\u009c\2\u009e\2\u00a0\2\u00a2\2\u00a4\2\u00a6\2\u00a8" + - "\2\u00aa\2\u00ac\2\u00ae\2\u00b0\2\u00b2\2\u00b4\2\u00b6\2\u00b8\2\u00ba" + - "\2\u00bc\2\u00be\2\u00c0\2\u00c2\2\u00c4\2\u00c6\2\u00c8\2\u00ca\2\u00cc" + - "\2\u00ce\2\u00d0\2\u00d2\2\u00d4\2\u00d6\2\u00d8\2\u00da\2\u00dc\2\u00de" + - "\2\u00e0\2\u00e2\2\u00e4\2\u00e6\2\u00e8\2\u00ea\2\u00ec\2\u00ee\2\u00f0" + - "\2\u00f2\2\u00f4\2\u00f6\2\u00f8\2\u00fa\2\u00fc\2\u00fe\2\u0100\2\u0102" + - "\2\u0104\2\u0106\2\u0108\2\u010a\2\u010c\2\u010e\2\u0110\2\u0112\2\u0114" + - "\2\u0116\2\u0118\2\u011a\2\u011c\2\u011e\2\u0120\2\u0122\2\u0124\2\u0126" + - "\2\u0128\2\u012a\2\u012c\2\u012e\2\u0130\2\u0132\2\u0134\2\u0136\2\u0138" + - "\2\u013a\2\u013c\2\u013e\2\u0140\2\u0142\2\u0144\2\u0146\2\u0148\2\u014a" + - "\2\u014c\2\u014e\2\u0150\2\u0152\2\u0154\2\u0156\2\u0158\2\u015a\2\u015c" + - "\2\u015e\2\u0160\2\u0162\2\u0164\2\u0166\2\u0168\2\u016a\2\u016c\2\u016e" + - "\2\u0170\2\u0172\2\u0174\2\u0176\2\u0178\2\u017a\2\u017c\2\u017e\2\u0180" + - "\2\u0182\2\u0184\2\u0186\2\u0188\2\u018a\2\u018c\2\u018e\2\u0190\2\u0192" + - "\2\u0194\2\u0196\2\u0198\2\u019a\2\u019c\2\u019e\2\u01a0\2\u01a2\2\u01a4" + - "\2\u01a6\2\u01a8\2\u01aa\2\u01ac\2\u01ae\2\u01b0\2\u01b2\2\u01b4\2\u01b6" + - "\2\u01b8\2\u01ba\2\u01bc\2\u01be\2\u01c0\2\u01c2\2\u01c4\2\u01c6\2\u01c8" + - "\2\u01ca\2\u01cc\2\u01ce\2\u01d0\2\u01d2\2\u01d4\2\u01d6\2\u01d8\2\u01da" + - "\2\2\6\3\2\65:\7\2\7\7\n\n\35\35\37\37\'\'\4\2\20\20\26\26\4\2DD]g\u0c1d" + - "\2\u01dc\3\2\2\2\4\u01e0\3\2\2\2\6\u01f0\3\2\2\2\b\u01f4\3\2\2\2\n\u01f6" + - "\3\2\2\2\f\u01f8\3\2\2\2\16\u01fd\3\2\2\2\20\u0201\3\2\2\2\22\u0220\3" + - "\2\2\2\24\u0222\3\2\2\2\26\u0230\3\2\2\2\30\u0237\3\2\2\2\32\u0239\3\2" + - "\2\2\34\u023b\3\2\2\2\36\u0240\3\2\2\2 \u024e\3\2\2\2\"\u0253\3\2\2\2" + - "$\u0268\3\2\2\2&\u026f\3\2\2\2(\u027b\3\2\2\2*\u027d\3\2\2\2,\u0280\3" + - "\2\2\2.\u0284\3\2\2\2\60\u028e\3\2\2\2\62\u0293\3\2\2\2\64\u029e\3\2\2" + - "\2\66\u02a0\3\2\2\28\u02b0\3\2\2\2:\u02b2\3\2\2\2<\u02c2\3\2\2\2>\u02c4" + - "\3\2\2\2@\u02c6\3\2\2\2B\u02d2\3\2\2\2D\u02e5\3\2\2\2F\u02f3\3\2\2\2H" + - "\u02f9\3\2\2\2J\u02fb\3\2\2\2L\u02ff\3\2\2\2N\u0305\3\2\2\2P\u030c\3\2" + - "\2\2R\u0316\3\2\2\2T\u031a\3\2\2\2V\u031f\3\2\2\2X\u0337\3\2\2\2Z\u0339" + - "\3\2\2\2\\\u033d\3\2\2\2^\u0345\3\2\2\2`\u0348\3\2\2\2b\u034b\3\2\2\2" + - "d\u0353\3\2\2\2f\u0360\3\2\2\2h\u0367\3\2\2\2j\u036c\3\2\2\2l\u037b\3" + - "\2\2\2n\u037d\3\2\2\2p\u0385\3\2\2\2r\u038a\3\2\2\2t\u0390\3\2\2\2v\u0394" + - "\3\2\2\2x\u0398\3\2\2\2z\u039d\3\2\2\2|\u03a1\3\2\2\2~\u03ba\3\2\2\2\u0080" + - "\u03bc\3\2\2\2\u0082\u03c7\3\2\2\2\u0084\u03cb\3\2\2\2\u0086\u03cd\3\2" + - "\2\2\u0088\u03cf\3\2\2\2\u008a\u03d1\3\2\2\2\u008c\u03dc\3\2\2\2\u008e" + - "\u03e1\3\2\2\2\u0090\u03f1\3\2\2\2\u0092\u0404\3\2\2\2\u0094\u0408\3\2" + - "\2\2\u0096\u040a\3\2\2\2\u0098\u0418\3\2\2\2\u009a\u042a\3\2\2\2\u009c" + - "\u042f\3\2\2\2\u009e\u0437\3\2\2\2\u00a0\u044a\3\2\2\2\u00a2\u044f\3\2" + - "\2\2\u00a4\u0459\3\2\2\2\u00a6\u045c\3\2\2\2\u00a8\u0466\3\2\2\2\u00aa" + - "\u046a\3\2\2\2\u00ac\u046c\3\2\2\2\u00ae\u046e\3\2\2\2\u00b0\u0474\3\2" + - "\2\2\u00b2\u0481\3\2\2\2\u00b4\u0484\3\2\2\2\u00b6\u048d\3\2\2\2\u00b8" + - "\u048f\3\2\2\2\u00ba\u04c6\3\2\2\2\u00bc\u04cb\3\2\2\2\u00be\u04d5\3\2" + - "\2\2\u00c0\u04e1\3\2\2\2\u00c2\u04ec\3\2\2\2\u00c4\u04fa\3\2\2\2\u00c6" + - "\u04fc\3\2\2\2\u00c8\u0505\3\2\2\2\u00ca\u050a\3\2\2\2\u00cc\u051e\3\2" + - "\2\2\u00ce\u0520\3\2\2\2\u00d0\u0523\3\2\2\2\u00d2\u0531\3\2\2\2\u00d4" + - "\u0536\3\2\2\2\u00d6\u0541\3\2\2\2\u00d8\u0546\3\2\2\2\u00da\u0552\3\2" + - "\2\2\u00dc\u0557\3\2\2\2\u00de\u055f\3\2\2\2\u00e0\u056d\3\2\2\2\u00e2" + - "\u0572\3\2\2\2\u00e4\u0584\3\2\2\2\u00e6\u0586\3\2\2\2\u00e8\u058c\3\2" + - "\2\2\u00ea\u058e\3\2\2\2\u00ec\u0596\3\2\2\2\u00ee\u059e\3\2\2\2\u00f0" + - "\u05a5\3\2\2\2\u00f2\u05a7\3\2\2\2\u00f4\u05b0\3\2\2\2\u00f6\u05b8\3\2" + - "\2\2\u00f8\u05bb\3\2\2\2\u00fa\u05c1\3\2\2\2\u00fc\u05ca\3\2\2\2\u00fe" + - "\u05d2\3\2\2\2\u0100\u05d8\3\2\2\2\u0102\u05e2\3\2\2\2\u0104\u05e4\3\2" + - "\2\2\u0106\u05ea\3\2\2\2\u0108\u05f6\3\2\2\2\u010a\u05fd\3\2\2\2\u010c" + - "\u060b\3\2\2\2\u010e\u060d\3\2\2\2\u0110\u060f\3\2\2\2\u0112\u0613\3\2" + - "\2\2\u0114\u0617\3\2\2\2\u0116\u0621\3\2\2\2\u0118\u0623\3\2\2\2\u011a" + - "\u0629\3\2\2\2\u011c\u0631\3\2\2\2\u011e\u0643\3\2\2\2\u0120\u0645\3\2" + - "\2\2\u0122\u064b\3\2\2\2\u0124\u065a\3\2\2\2\u0126\u065d\3\2\2\2\u0128" + - "\u066e\3\2\2\2\u012a\u0670\3\2\2\2\u012c\u0672\3\2\2\2\u012e\u0678\3\2" + - "\2\2\u0130\u067e\3\2\2\2\u0132\u0688\3\2\2\2\u0134\u068c\3\2\2\2\u0136" + - "\u068e\3\2\2\2\u0138\u069e\3\2\2\2\u013a\u06b0\3\2\2\2\u013c\u06b2\3\2" + - "\2\2\u013e\u06b4\3\2\2\2\u0140\u06bc\3\2\2\2\u0142\u06cb\3\2\2\2\u0144" + - "\u06da\3\2\2\2\u0146\u06e0\3\2\2\2\u0148\u06e6\3\2\2\2\u014a\u06ec\3\2" + - "\2\2\u014c\u06f0\3\2\2\2\u014e\u0702\3\2\2\2\u0150\u0704\3\2\2\2\u0152" + - "\u070b\3\2\2\2\u0154\u0714\3\2\2\2\u0156\u071a\3\2\2\2\u0158\u0722\3\2" + - "\2\2\u015a\u0725\3\2\2\2\u015c\u072e\3\2\2\2\u015e\u0735\3\2\2\2\u0160" + - "\u0740\3\2\2\2\u0162\u074a\3\2\2\2\u0164\u076f\3\2\2\2\u0166\u0771\3\2" + - "\2\2\u0168\u078f\3\2\2\2\u016a\u0796\3\2\2\2\u016c\u0798\3\2\2\2\u016e" + - "\u079e\3\2\2\2\u0170\u07c8\3\2\2\2\u0172\u07ca\3\2\2\2\u0174\u07f3\3\2" + - "\2\2\u0176\u0848\3\2\2\2\u0178\u084a\3\2\2\2\u017a\u089c\3\2\2\2\u017c" + - "\u08a1\3\2\2\2\u017e\u08b0\3\2\2\2\u0180\u08b2\3\2\2\2\u0182\u08be\3\2" + - "\2\2\u0184\u08ca\3\2\2\2\u0186\u08d6\3\2\2\2\u0188\u08ef\3\2\2\2\u018a" + - "\u093f\3\2\2\2\u018c\u0941\3\2\2\2\u018e\u0984\3\2\2\2\u0190\u0986\3\2" + - "\2\2\u0192\u09bd\3\2\2\2\u0194\u09bf\3\2\2\2\u0196\u09ed\3\2\2\2\u0198" + - "\u0a05\3\2\2\2\u019a\u0a07\3\2\2\2\u019c\u0a11\3\2\2\2\u019e\u0a18\3\2" + - "\2\2\u01a0\u0a1c\3\2\2\2\u01a2\u0a1e\3\2\2\2\u01a4\u0a2c\3\2\2\2\u01a6" + - "\u0a2e\3\2\2\2\u01a8\u0a38\3\2\2\2\u01aa\u0a3c\3\2\2\2\u01ac\u0a3e\3\2" + - "\2\2\u01ae\u0a45\3\2\2\2\u01b0\u0a47\3\2\2\2\u01b2\u0a50\3\2\2\2\u01b4" + - "\u0a52\3\2\2\2\u01b6\u0a5d\3\2\2\2\u01b8\u0a68\3\2\2\2\u01ba\u0a73\3\2" + - "\2\2\u01bc\u0a7e\3\2\2\2\u01be\u0a89\3\2\2\2\u01c0\u0a97\3\2\2\2\u01c2" + - "\u0aae\3\2\2\2\u01c4\u0ac3\3\2\2\2\u01c6\u0ad1\3\2\2\2\u01c8\u0ae9\3\2" + - "\2\2\u01ca\u0aeb\3\2\2\2\u01cc\u0aee\3\2\2\2\u01ce\u0af7\3\2\2\2\u01d0" + - "\u0afb\3\2\2\2\u01d2\u0b04\3\2\2\2\u01d4\u0b07\3\2\2\2\u01d6\u0b09\3\2" + - "\2\2\u01d8\u0b0c\3\2\2\2\u01da\u0b29\3\2\2\2\u01dc\u01dd\t\2\2\2\u01dd" + - "\3\3\2\2\2\u01de\u01e1\5\6\4\2\u01df\u01e1\5\16\b\2\u01e0\u01de\3\2\2" + - "\2\u01e0\u01df\3\2\2\2\u01e1\5\3\2\2\2\u01e2\u01e4\5\u00e8u\2\u01e3\u01e2" + - "\3\2\2\2\u01e4\u01e7\3\2\2\2\u01e5\u01e3\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6" + - "\u01e8\3\2\2\2\u01e7\u01e5\3\2\2\2\u01e8\u01f1\5\b\5\2\u01e9\u01eb\5\u00e8" + - "u\2\u01ea\u01e9\3\2\2\2\u01eb\u01ee\3\2\2\2\u01ec\u01ea\3\2\2\2\u01ec" + - "\u01ed\3\2\2\2\u01ed\u01ef\3\2\2\2\u01ee\u01ec\3\2\2\2\u01ef\u01f1\7\5" + - "\2\2\u01f0\u01e5\3\2\2\2\u01f0\u01ec\3\2\2\2\u01f1\7\3\2\2\2\u01f2\u01f5" + - "\5\n\6\2\u01f3\u01f5\5\f\7\2\u01f4\u01f2\3\2\2\2\u01f4\u01f3\3\2\2\2\u01f5" + - "\t\3\2\2\2\u01f6\u01f7\t\3\2\2\u01f7\13\3\2\2\2\u01f8\u01f9\t\4\2\2\u01f9" + - "\r\3\2\2\2\u01fa\u01fe\5\20\t\2\u01fb\u01fe\5\36\20\2\u01fc\u01fe\5 \21" + - "\2\u01fd\u01fa\3\2\2\2\u01fd\u01fb\3\2\2\2\u01fd\u01fc\3\2\2\2\u01fe\17" + - "\3\2\2\2\u01ff\u0202\5\26\f\2\u0200\u0202\5\34\17\2\u0201\u01ff\3\2\2" + - "\2\u0201\u0200\3\2\2\2\u0202\u0207\3\2\2\2\u0203\u0206\5\24\13\2\u0204" + - "\u0206\5\32\16\2\u0205\u0203\3\2\2\2\u0205\u0204\3\2\2\2\u0206\u0209\3" + - "\2\2\2\u0207\u0205\3\2\2\2\u0207\u0208\3\2\2\2\u0208\21\3\2\2\2\u0209" + - "\u0207\3\2\2\2\u020a\u020c\5\u00e8u\2\u020b\u020a\3\2\2\2\u020c\u020f" + - "\3\2\2\2\u020d\u020b\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u0210\3\2\2\2\u020f" + - "\u020d\3\2\2\2\u0210\u0212\7h\2\2\u0211\u0213\5,\27\2\u0212\u0211\3\2" + - "\2\2\u0212\u0213\3\2\2\2\u0213\u0221\3\2\2\2\u0214\u0215\5\20\t\2\u0215" + - "\u0219\7C\2\2\u0216\u0218\5\u00e8u\2\u0217\u0216\3\2\2\2\u0218\u021b\3" + - "\2\2\2\u0219\u0217\3\2\2\2\u0219\u021a\3\2\2\2\u021a\u021c\3\2\2\2\u021b" + - "\u0219\3\2\2\2\u021c\u021e\7h\2\2\u021d\u021f\5,\27\2\u021e\u021d\3\2" + - "\2\2\u021e\u021f\3\2\2\2\u021f\u0221\3\2\2\2\u0220\u020d\3\2\2\2\u0220" + - "\u0214\3\2\2\2\u0221\23\3\2\2\2\u0222\u0226\7C\2\2\u0223\u0225\5\u00e8" + - "u\2\u0224\u0223\3\2\2\2\u0225\u0228\3\2\2\2\u0226\u0224\3\2\2\2\u0226" + - "\u0227\3\2\2\2\u0227\u0229\3\2\2\2\u0228\u0226\3\2\2\2\u0229\u022b\7h" + - "\2\2\u022a\u022c\5,\27\2\u022b\u022a\3\2\2\2\u022b\u022c\3\2\2\2\u022c" + - "\25\3\2\2\2\u022d\u022f\5\u00e8u\2\u022e\u022d\3\2\2\2\u022f\u0232\3\2" + - "\2\2\u0230\u022e\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0233\3\2\2\2\u0232" + - "\u0230\3\2\2\2\u0233\u0235\7h\2\2\u0234\u0236\5,\27\2\u0235\u0234\3\2" + - "\2\2\u0235\u0236\3\2\2\2\u0236\27\3\2\2\2\u0237\u0238\5\22\n\2\u0238\31" + - "\3\2\2\2\u0239\u023a\5\24\13\2\u023a\33\3\2\2\2\u023b\u023c\5\26\f\2\u023c" + - "\35\3\2\2\2\u023d\u023f\5\u00e8u\2\u023e\u023d\3\2\2\2\u023f\u0242\3\2" + - "\2\2\u0240\u023e\3\2\2\2\u0240\u0241\3\2\2\2\u0241\u0243\3\2\2\2\u0242" + - "\u0240\3\2\2\2\u0243\u0244\7h\2\2\u0244\37\3\2\2\2\u0245\u0246\5\6\4\2" + - "\u0246\u0247\5\"\22\2\u0247\u024f\3\2\2\2\u0248\u0249\5\20\t\2\u0249\u024a" + - "\5\"\22\2\u024a\u024f\3\2\2\2\u024b\u024c\5\36\20\2\u024c\u024d\5\"\22" + - "\2\u024d\u024f\3\2\2\2\u024e\u0245\3\2\2\2\u024e\u0248\3\2\2\2\u024e\u024b" + - "\3\2\2\2\u024f!\3\2\2\2\u0250\u0252\5\u00e8u\2\u0251\u0250\3\2\2\2\u0252" + - "\u0255\3\2\2\2\u0253\u0251\3\2\2\2\u0253\u0254\3\2\2\2\u0254\u0256\3\2" + - "\2\2\u0255\u0253\3\2\2\2\u0256\u0257\7?\2\2\u0257\u0262\7@\2\2\u0258\u025a" + - "\5\u00e8u\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2" + - "\2\u025b\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f" + - "\7?\2\2\u025f\u0261\7@\2\2\u0260\u025b\3\2\2\2\u0261\u0264\3\2\2\2\u0262" + - "\u0260\3\2\2\2\u0262\u0263\3\2\2\2\u0263#\3\2\2\2\u0264\u0262\3\2\2\2" + - "\u0265\u0267\5&\24\2\u0266\u0265\3\2\2\2\u0267\u026a\3\2\2\2\u0268\u0266" + - "\3\2\2\2\u0268\u0269\3\2\2\2\u0269\u026b\3\2\2\2\u026a\u0268\3\2\2\2\u026b" + - "\u026d\7h\2\2\u026c\u026e\5(\25\2\u026d\u026c\3\2\2\2\u026d\u026e\3\2" + - "\2\2\u026e%\3\2\2\2\u026f\u0270\5\u00e8u\2\u0270\'\3\2\2\2\u0271\u0272" + - "\7\23\2\2\u0272\u027c\5\36\20\2\u0273\u0274\7\23\2\2\u0274\u0278\5\20" + - "\t\2\u0275\u0277\5*\26\2\u0276\u0275\3\2\2\2\u0277\u027a\3\2\2\2\u0278" + - "\u0276\3\2\2\2\u0278\u0279\3\2\2\2\u0279\u027c\3\2\2\2\u027a\u0278\3\2" + - "\2\2\u027b\u0271\3\2\2\2\u027b\u0273\3\2\2\2\u027c)\3\2\2\2\u027d\u027e" + - "\7W\2\2\u027e\u027f\5\30\r\2\u027f+\3\2\2\2\u0280\u0281\7F\2\2\u0281\u0282" + - "\5.\30\2\u0282\u0283\7E\2\2\u0283-\3\2\2\2\u0284\u0289\5\60\31\2\u0285" + - "\u0286\7B\2\2\u0286\u0288\5\60\31\2\u0287\u0285\3\2\2\2\u0288\u028b\3" + - "\2\2\2\u0289\u0287\3\2\2\2\u0289\u028a\3\2\2\2\u028a/\3\2\2\2\u028b\u0289" + - "\3\2\2\2\u028c\u028f\5\16\b\2\u028d\u028f\5\62\32\2\u028e\u028c\3\2\2" + - "\2\u028e\u028d\3\2\2\2\u028f\61\3\2\2\2\u0290\u0292\5\u00e8u\2\u0291\u0290" + - "\3\2\2\2\u0292\u0295\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0294\3\2\2\2\u0294" + - "\u0296\3\2\2\2\u0295\u0293\3\2\2\2\u0296\u0298\7I\2\2\u0297\u0299\5\64" + - "\33\2\u0298\u0297\3\2\2\2\u0298\u0299\3\2\2\2\u0299\63\3\2\2\2\u029a\u029b" + - "\7\23\2\2\u029b\u029f\5\16\b\2\u029c\u029d\7*\2\2\u029d\u029f\5\16\b\2" + - "\u029e\u029a\3\2\2\2\u029e\u029c\3\2\2\2\u029f\65\3\2\2\2\u02a0\u02a1" + - "\b\34\1\2\u02a1\u02a2\7h\2\2\u02a2\u02a8\3\2\2\2\u02a3\u02a4\f\3\2\2\u02a4" + - "\u02a5\7C\2\2\u02a5\u02a7\7h\2\2\u02a6\u02a3\3\2\2\2\u02a7\u02aa\3\2\2" + - "\2\u02a8\u02a6\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9\67\3\2\2\2\u02aa\u02a8" + - "\3\2\2\2\u02ab\u02b1\7h\2\2\u02ac\u02ad\5:\36\2\u02ad\u02ae\7C\2\2\u02ae" + - "\u02af\7h\2\2\u02af\u02b1\3\2\2\2\u02b0\u02ab\3\2\2\2\u02b0\u02ac\3\2" + - "\2\2\u02b19\3\2\2\2\u02b2\u02b3\b\36\1\2\u02b3\u02b4\7h\2\2\u02b4\u02ba" + - "\3\2\2\2\u02b5\u02b6\f\3\2\2\u02b6\u02b7\7C\2\2\u02b7\u02b9\7h\2\2\u02b8" + - "\u02b5\3\2\2\2\u02b9\u02bc\3\2\2\2\u02ba\u02b8\3\2\2\2\u02ba\u02bb\3\2" + - "\2\2\u02bb;\3\2\2\2\u02bc\u02ba\3\2\2\2\u02bd\u02c3\7h\2\2\u02be\u02bf" + - "\5@!\2\u02bf\u02c0\7C\2\2\u02c0\u02c1\7h\2\2\u02c1\u02c3\3\2\2\2\u02c2" + - "\u02bd\3\2\2\2\u02c2\u02be\3\2\2\2\u02c3=\3\2\2\2\u02c4\u02c5\7h\2\2\u02c5" + - "?\3\2\2\2\u02c6\u02c7\b!\1\2\u02c7\u02c8\7h\2\2\u02c8\u02ce\3\2\2\2\u02c9" + - "\u02ca\f\3\2\2\u02ca\u02cb\7C\2\2\u02cb\u02cd\7h\2\2\u02cc\u02c9\3\2\2" + - "\2\u02cd\u02d0\3\2\2\2\u02ce\u02cc\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cfA" + - "\3\2\2\2\u02d0\u02ce\3\2\2\2\u02d1\u02d3\5D#\2\u02d2\u02d1\3\2\2\2\u02d2" + - "\u02d3\3\2\2\2\u02d3\u02d7\3\2\2\2\u02d4\u02d6\5H%\2\u02d5\u02d4\3\2\2" + - "\2\u02d6\u02d9\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8\u02dd" + - "\3\2\2\2\u02d9\u02d7\3\2\2\2\u02da\u02dc\5R*\2\u02db\u02da\3\2\2\2\u02dc" + - "\u02df\3\2\2\2\u02dd\u02db\3\2\2\2\u02dd\u02de\3\2\2\2\u02de\u02e0\3\2" + - "\2\2\u02df\u02dd\3\2\2\2\u02e0\u02e1\7\2\2\3\u02e1C\3\2\2\2\u02e2\u02e4" + - "\5F$\2\u02e3\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5" + - "\u02e6\3\2\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\7\"" + - "\2\2\u02e9\u02ee\7h\2\2\u02ea\u02eb\7C\2\2\u02eb\u02ed\7h\2\2\u02ec\u02ea" + - "\3\2\2\2\u02ed\u02f0\3\2\2\2\u02ee\u02ec\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef" + - "\u02f1\3\2\2\2\u02f0\u02ee\3\2\2\2\u02f1\u02f2\7A\2\2\u02f2E\3\2\2\2\u02f3" + - "\u02f4\5\u00e8u\2\u02f4G\3\2\2\2\u02f5\u02fa\5J&\2\u02f6\u02fa\5L\'\2" + - "\u02f7\u02fa\5N(\2\u02f8\u02fa\5P)\2\u02f9\u02f5\3\2\2\2\u02f9\u02f6\3" + - "\2\2\2\u02f9\u02f7\3\2\2\2\u02f9\u02f8\3\2\2\2\u02faI\3\2\2\2\u02fb\u02fc" + - "\7\33\2\2\u02fc\u02fd\58\35\2\u02fd\u02fe\7A\2\2\u02feK\3\2\2\2\u02ff" + - "\u0300\7\33\2\2\u0300\u0301\5:\36\2\u0301\u0302\7C\2\2\u0302\u0303\7U" + - "\2\2\u0303\u0304\7A\2\2\u0304M\3\2\2\2\u0305\u0306\7\33\2\2\u0306\u0307" + - "\7(\2\2\u0307\u0308\58\35\2\u0308\u0309\7C\2\2\u0309\u030a\7h\2\2\u030a" + - "\u030b\7A\2\2\u030bO\3\2\2\2\u030c\u030d\7\33\2\2\u030d\u030e\7(\2\2\u030e" + - "\u030f\58\35\2\u030f\u0310\7C\2\2\u0310\u0311\7U\2\2\u0311\u0312\7A\2" + - "\2\u0312Q\3\2\2\2\u0313\u0317\5T+\2\u0314\u0317\5\u00c8e\2\u0315\u0317" + - "\7A\2\2\u0316\u0313\3\2\2\2\u0316\u0314\3\2\2\2\u0316\u0315\3\2\2\2\u0317" + - "S\3\2\2\2\u0318\u031b\5V,\2\u0319\u031b\5\u00bc_\2\u031a\u0318\3\2\2\2" + - "\u031a\u0319\3\2\2\2\u031bU\3\2\2\2\u031c\u031e\5X-\2\u031d\u031c\3\2" + - "\2\2\u031e\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320" + - "\u0322\3\2\2\2\u0321\u031f\3\2\2\2\u0322\u0323\7\13\2\2\u0323\u0325\7" + - "h\2\2\u0324\u0326\5Z.\2\u0325\u0324\3\2\2\2\u0325\u0326\3\2\2\2\u0326" + - "\u0328\3\2\2\2\u0327\u0329\5^\60\2\u0328\u0327\3\2\2\2\u0328\u0329\3\2" + - "\2\2\u0329\u032b\3\2\2\2\u032a\u032c\5`\61\2\u032b\u032a\3\2\2\2\u032b" + - "\u032c\3\2\2\2\u032c\u032d\3\2\2\2\u032d\u032e\5d\63\2\u032eW\3\2\2\2" + - "\u032f\u0338\5\u00e8u\2\u0330\u0338\7%\2\2\u0331\u0338\7$\2\2\u0332\u0338" + - "\7#\2\2\u0333\u0338\7\3\2\2\u0334\u0338\7(\2\2\u0335\u0338\7\24\2\2\u0336" + - "\u0338\7)\2\2\u0337\u032f\3\2\2\2\u0337\u0330\3\2\2\2\u0337\u0331\3\2" + - "\2\2\u0337\u0332\3\2\2\2\u0337\u0333\3\2\2\2\u0337\u0334\3\2\2\2\u0337" + - "\u0335\3\2\2\2\u0337\u0336\3\2\2\2\u0338Y\3\2\2\2\u0339\u033a\7F\2\2\u033a" + - "\u033b\5\\/\2\u033b\u033c\7E\2\2\u033c[\3\2\2\2\u033d\u0342\5$\23\2\u033e" + - "\u033f\7B\2\2\u033f\u0341\5$\23\2\u0340\u033e\3\2\2\2\u0341\u0344\3\2" + - "\2\2\u0342\u0340\3\2\2\2\u0342\u0343\3\2\2\2\u0343]\3\2\2\2\u0344\u0342" + - "\3\2\2\2\u0345\u0346\7\23\2\2\u0346\u0347\5\22\n\2\u0347_\3\2\2\2\u0348" + - "\u0349\7\32\2\2\u0349\u034a\5b\62\2\u034aa\3\2\2\2\u034b\u0350\5\30\r" + - "\2\u034c\u034d\7B\2\2\u034d\u034f\5\30\r\2\u034e\u034c\3\2\2\2\u034f\u0352" + - "\3\2\2\2\u0350\u034e\3\2\2\2\u0350\u0351\3\2\2\2\u0351c\3\2\2\2\u0352" + - "\u0350\3\2\2\2\u0353\u0357\7=\2\2\u0354\u0356\5f\64\2\u0355\u0354\3\2" + - "\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357\u0358\3\2\2\2\u0358" + - "\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\7>\2\2\u035be\3\2\2\2\u035c" + - "\u0361\5h\65\2\u035d\u0361\5\u00acW\2\u035e\u0361\5\u00aeX\2\u035f\u0361" + - "\5\u00b0Y\2\u0360\u035c\3\2\2\2\u0360\u035d\3\2\2\2\u0360\u035e\3\2\2" + - "\2\u0360\u035f\3\2\2\2\u0361g\3\2\2\2\u0362\u0368\5j\66\2\u0363\u0368" + - "\5\u008eH\2\u0364\u0368\5T+\2\u0365\u0368\5\u00c8e\2\u0366\u0368\7A\2" + - "\2\u0367\u0362\3\2\2\2\u0367\u0363\3\2\2\2\u0367\u0364\3\2\2\2\u0367\u0365" + - "\3\2\2\2\u0367\u0366\3\2\2\2\u0368i\3\2\2\2\u0369\u036b\5l\67\2\u036a" + - "\u0369\3\2\2\2\u036b\u036e\3\2\2\2\u036c\u036a\3\2\2\2\u036c\u036d\3\2" + - "\2\2\u036d\u036f\3\2\2\2\u036e\u036c\3\2\2\2\u036f\u0370\5v<\2\u0370\u0371" + - "\5n8\2\u0371\u0372\7A\2\2\u0372k\3\2\2\2\u0373\u037c\5\u00e8u\2\u0374" + - "\u037c\7%\2\2\u0375\u037c\7$\2\2\u0376\u037c\7#\2\2\u0377\u037c\7(\2\2" + - "\u0378\u037c\7\24\2\2\u0379\u037c\7\60\2\2\u037a\u037c\7\63\2\2\u037b" + - "\u0373\3\2\2\2\u037b\u0374\3\2\2\2\u037b\u0375\3\2\2\2\u037b\u0376\3\2" + - "\2\2\u037b\u0377\3\2\2\2\u037b\u0378\3\2\2\2\u037b\u0379\3\2\2\2\u037b" + - "\u037a\3\2\2\2\u037cm\3\2\2\2\u037d\u0382\5p9\2\u037e\u037f\7B\2\2\u037f" + - "\u0381\5p9\2\u0380\u037e\3\2\2\2\u0381\u0384\3\2\2\2\u0382\u0380\3\2\2" + - "\2\u0382\u0383\3\2\2\2\u0383o\3\2\2\2\u0384\u0382\3\2\2\2\u0385\u0388" + - "\5r:\2\u0386\u0387\7D\2\2\u0387\u0389\5t;\2\u0388\u0386\3\2\2\2\u0388" + - "\u0389\3\2\2\2\u0389q\3\2\2\2\u038a\u038c\7h\2\2\u038b\u038d\5\"\22\2" + - "\u038c\u038b\3\2\2\2\u038c\u038d\3\2\2\2\u038ds\3\2\2\2\u038e\u0391\5" + - "\u01a0\u00d1\2\u038f\u0391\5\u00fa~\2\u0390\u038e\3\2\2\2\u0390\u038f" + - "\3\2\2\2\u0391u\3\2\2\2\u0392\u0395\5x=\2\u0393\u0395\5z>\2\u0394\u0392" + - "\3\2\2\2\u0394\u0393\3\2\2\2\u0395w\3\2\2\2\u0396\u0399\5\b\5\2\u0397" + - "\u0399\7\5\2\2\u0398\u0396\3\2\2\2\u0398\u0397\3\2\2\2\u0399y\3\2\2\2" + - "\u039a\u039e\5|?\2\u039b\u039e\5\u008aF\2\u039c\u039e\5\u008cG\2\u039d" + - "\u039a\3\2\2\2\u039d\u039b\3\2\2\2\u039d\u039c\3\2\2\2\u039e{\3\2\2\2" + - "\u039f\u03a2\5\u0082B\2\u03a0\u03a2\5\u0088E\2\u03a1\u039f\3\2\2\2\u03a1" + - "\u03a0\3\2\2\2\u03a2\u03a7\3\2\2\2\u03a3\u03a6\5\u0080A\2\u03a4\u03a6" + - "\5\u0086D\2\u03a5\u03a3\3\2\2\2\u03a5\u03a4\3\2\2\2\u03a6\u03a9\3\2\2" + - "\2\u03a7\u03a5\3\2\2\2\u03a7\u03a8\3\2\2\2\u03a8}\3\2\2\2\u03a9\u03a7" + - "\3\2\2\2\u03aa\u03ac\7h\2\2\u03ab\u03ad\5,\27\2\u03ac\u03ab\3\2\2\2\u03ac" + - "\u03ad\3\2\2\2\u03ad\u03bb\3\2\2\2\u03ae\u03af\5|?\2\u03af\u03b3\7C\2" + - "\2\u03b0\u03b2\5\u00e8u\2\u03b1\u03b0\3\2\2\2\u03b2\u03b5\3\2\2\2\u03b3" + - "\u03b1\3\2\2\2\u03b3\u03b4\3\2\2\2\u03b4\u03b6\3\2\2\2\u03b5\u03b3\3\2" + - "\2\2\u03b6\u03b8\7h\2\2\u03b7\u03b9\5,\27\2\u03b8\u03b7\3\2\2\2\u03b8" + - "\u03b9\3\2\2\2\u03b9\u03bb\3\2\2\2\u03ba\u03aa\3\2\2\2\u03ba\u03ae\3\2" + - "\2\2\u03bb\177\3\2\2\2\u03bc\u03c0\7C\2\2\u03bd\u03bf\5\u00e8u\2\u03be" + - "\u03bd\3\2\2\2\u03bf\u03c2\3\2\2\2\u03c0\u03be\3\2\2\2\u03c0\u03c1\3\2" + - "\2\2\u03c1\u03c3\3\2\2\2\u03c2\u03c0\3\2\2\2\u03c3\u03c5\7h\2\2\u03c4" + - "\u03c6\5,\27\2\u03c5\u03c4\3\2\2\2\u03c5\u03c6\3\2\2\2\u03c6\u0081\3\2" + - "\2\2\u03c7\u03c9\7h\2\2\u03c8\u03ca\5,\27\2\u03c9\u03c8\3\2\2\2\u03c9" + - "\u03ca\3\2\2\2\u03ca\u0083\3\2\2\2\u03cb\u03cc\5~@\2\u03cc\u0085\3\2\2" + - "\2\u03cd\u03ce\5\u0080A\2\u03ce\u0087\3\2\2\2\u03cf\u03d0\5\u0082B\2\u03d0" + - "\u0089\3\2\2\2\u03d1\u03d2\7h\2\2\u03d2\u008b\3\2\2\2\u03d3\u03d4\5x=" + - "\2\u03d4\u03d5\5\"\22\2\u03d5\u03dd\3\2\2\2\u03d6\u03d7\5|?\2\u03d7\u03d8" + - "\5\"\22\2\u03d8\u03dd\3\2\2\2\u03d9\u03da\5\u008aF\2\u03da\u03db\5\"\22" + - "\2\u03db\u03dd\3\2\2\2\u03dc\u03d3\3\2\2\2\u03dc\u03d6\3\2\2\2\u03dc\u03d9" + - "\3\2\2\2\u03dd\u008d\3\2\2\2\u03de\u03e0\5\u0090I\2\u03df\u03de\3\2\2" + - "\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2\u03e4" + - "\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5\u0092J\2\u03e5\u03e6\5\u00aa" + - "V\2\u03e6\u008f\3\2\2\2\u03e7\u03f2\5\u00e8u\2\u03e8\u03f2\7%\2\2\u03e9" + - "\u03f2\7$\2\2\u03ea\u03f2\7#\2\2\u03eb\u03f2\7\3\2\2\u03ec\u03f2\7(\2" + - "\2\u03ed\u03f2\7\24\2\2\u03ee\u03f2\7,\2\2\u03ef\u03f2\7 \2\2\u03f0\u03f2" + - "\7)\2\2\u03f1\u03e7\3\2\2\2\u03f1\u03e8\3\2\2\2\u03f1\u03e9\3\2\2\2\u03f1" + - "\u03ea\3\2\2\2\u03f1\u03eb\3\2\2\2\u03f1\u03ec\3\2\2\2\u03f1\u03ed\3\2" + - "\2\2\u03f1\u03ee\3\2\2\2\u03f1\u03ef\3\2\2\2\u03f1\u03f0\3\2\2\2\u03f2" + - "\u0091\3\2\2\2\u03f3\u03f4\5\u0094K\2\u03f4\u03f6\5\u0096L\2\u03f5\u03f7" + - "\5\u00a4S\2\u03f6\u03f5\3\2\2\2\u03f6\u03f7\3\2\2\2\u03f7\u0405\3\2\2" + - "\2\u03f8\u03fc\5Z.\2\u03f9\u03fb\5\u00e8u\2\u03fa\u03f9\3\2\2\2\u03fb" + - "\u03fe\3\2\2\2\u03fc\u03fa\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd\u03ff\3\2" + - "\2\2\u03fe\u03fc\3\2\2\2\u03ff\u0400\5\u0094K\2\u0400\u0402\5\u0096L\2" + - "\u0401\u0403\5\u00a4S\2\u0402\u0401\3\2\2\2\u0402\u0403\3\2\2\2\u0403" + - "\u0405\3\2\2\2\u0404\u03f3\3\2\2\2\u0404\u03f8\3\2\2\2\u0405\u0093\3\2" + - "\2\2\u0406\u0409\5v<\2\u0407\u0409\7\62\2\2\u0408\u0406\3\2\2\2\u0408" + - "\u0407\3\2\2\2\u0409\u0095\3\2\2\2\u040a\u040b\7h\2\2\u040b\u040d\7;\2" + - "\2\u040c\u040e\5\u0098M\2\u040d\u040c\3\2\2\2\u040d\u040e\3\2\2\2\u040e" + - "\u040f\3\2\2\2\u040f\u0411\7<\2\2\u0410\u0412\5\"\22\2\u0411\u0410\3\2" + - "\2\2\u0411\u0412\3\2\2\2\u0412\u0097\3\2\2\2\u0413\u0414\5\u009aN\2\u0414" + - "\u0415\7B\2\2\u0415\u0416\5\u00a0Q\2\u0416\u0419\3\2\2\2\u0417\u0419\5" + - "\u00a0Q\2\u0418\u0413\3\2\2\2\u0418\u0417\3\2\2\2\u0419\u0099\3\2\2\2" + - "\u041a\u041f\5\u009cO\2\u041b\u041c\7B\2\2\u041c\u041e\5\u009cO\2\u041d" + - "\u041b\3\2\2\2\u041e\u0421\3\2\2\2\u041f\u041d\3\2\2\2\u041f\u0420\3\2" + - "\2\2\u0420\u042b\3\2\2\2\u0421\u041f\3\2\2\2\u0422\u0427\5\u00a2R\2\u0423" + - "\u0424\7B\2\2\u0424\u0426\5\u009cO\2\u0425\u0423\3\2\2\2\u0426\u0429\3" + - "\2\2\2\u0427\u0425\3\2\2\2\u0427\u0428\3\2\2\2\u0428\u042b\3\2\2\2\u0429" + - "\u0427\3\2\2\2\u042a\u041a\3\2\2\2\u042a\u0422\3\2\2\2\u042b\u009b\3\2" + - "\2\2\u042c\u042e\5\u009eP\2\u042d\u042c\3\2\2\2\u042e\u0431\3\2\2\2\u042f" + - "\u042d\3\2\2\2\u042f\u0430\3\2\2\2\u0430\u0432\3\2\2\2\u0431\u042f\3\2" + - "\2\2\u0432\u0433\5v<\2\u0433\u0434\5r:\2\u0434\u009d\3\2\2\2\u0435\u0438" + - "\5\u00e8u\2\u0436\u0438\7\24\2\2\u0437\u0435\3\2\2\2\u0437\u0436\3\2\2" + - "\2\u0438\u009f\3\2\2\2\u0439\u043b\5\u009eP\2\u043a\u0439\3\2\2\2\u043b" + - "\u043e\3\2\2\2\u043c\u043a\3\2\2\2\u043c\u043d\3\2\2\2\u043d\u043f\3\2" + - "\2\2\u043e\u043c\3\2\2\2\u043f\u0443\5v<\2\u0440\u0442\5\u00e8u\2\u0441" + - "\u0440\3\2\2\2\u0442\u0445\3\2\2\2\u0443\u0441\3\2\2\2\u0443\u0444\3\2" + - "\2\2\u0444\u0446\3\2\2\2\u0445\u0443\3\2\2\2\u0446\u0447\7j\2\2\u0447" + - "\u0448\5r:\2\u0448\u044b\3\2\2\2\u0449\u044b\5\u009cO\2\u044a\u043c\3" + - "\2\2\2\u044a\u0449\3\2\2\2\u044b\u00a1\3\2\2\2\u044c\u044e\5\u00e8u\2" + - "\u044d\u044c\3\2\2\2\u044e\u0451\3\2\2\2\u044f\u044d\3\2\2\2\u044f\u0450" + - "\3\2\2\2\u0450\u0452\3\2\2\2\u0451\u044f\3\2\2\2\u0452\u0455\5v<\2\u0453" + - "\u0454\7h\2\2\u0454\u0456\7C\2\2\u0455\u0453\3\2\2\2\u0455\u0456\3\2\2" + - "\2\u0456\u0457\3\2\2\2\u0457\u0458\7-\2\2\u0458\u00a3\3\2\2\2\u0459\u045a" + - "\7/\2\2\u045a\u045b\5\u00a6T\2\u045b\u00a5\3\2\2\2\u045c\u0461\5\u00a8" + - "U\2\u045d\u045e\7B\2\2\u045e\u0460\5\u00a8U\2\u045f\u045d\3\2\2\2\u0460" + - "\u0463\3\2\2\2\u0461\u045f\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u00a7\3\2" + - "\2\2\u0463\u0461\3\2\2\2\u0464\u0467\5\22\n\2\u0465\u0467\5\36\20\2\u0466" + - "\u0464\3\2\2\2\u0466\u0465\3\2\2\2\u0467\u00a9\3\2\2\2\u0468\u046b\5\u00fe" + - "\u0080\2\u0469\u046b\7A\2\2\u046a\u0468\3\2\2\2\u046a\u0469\3\2\2\2\u046b" + - "\u00ab\3\2\2\2\u046c\u046d\5\u00fe\u0080\2\u046d\u00ad\3\2\2\2\u046e\u046f" + - "\7(\2\2\u046f\u0470\5\u00fe\u0080\2\u0470\u00af\3\2\2\2\u0471\u0473\5" + - "\u00b2Z\2\u0472\u0471\3\2\2\2\u0473\u0476\3\2\2\2\u0474\u0472\3\2\2\2" + - "\u0474\u0475\3\2\2\2\u0475\u0477\3\2\2\2\u0476\u0474\3\2\2\2\u0477\u0479" + - "\5\u00b4[\2\u0478\u047a\5\u00a4S\2\u0479\u0478\3\2\2\2\u0479\u047a\3\2" + - "\2\2\u047a\u047b\3\2\2\2\u047b\u047c\5\u00b8]\2\u047c\u00b1\3\2\2\2\u047d" + - "\u0482\5\u00e8u\2\u047e\u0482\7%\2\2\u047f\u0482\7$\2\2\u0480\u0482\7" + - "#\2\2\u0481\u047d\3\2\2\2\u0481\u047e\3\2\2\2\u0481\u047f\3\2\2\2\u0481" + - "\u0480\3\2\2\2\u0482\u00b3\3\2\2\2\u0483\u0485\5Z.\2\u0484\u0483\3\2\2" + - "\2\u0484\u0485\3\2\2\2\u0485\u0486\3\2\2\2\u0486\u0487\5\u00b6\\\2\u0487" + - "\u0489\7;\2\2\u0488\u048a\5\u0098M\2\u0489\u0488\3\2\2\2\u0489\u048a\3" + - "\2\2\2\u048a\u048b\3\2\2\2\u048b\u048c\7<\2\2\u048c\u00b5\3\2\2\2\u048d" + - "\u048e\7h\2\2\u048e\u00b7\3\2\2\2\u048f\u0491\7=\2\2\u0490\u0492\5\u00ba" + - "^\2\u0491\u0490\3\2\2\2\u0491\u0492\3\2\2\2\u0492\u0494\3\2\2\2\u0493" + - "\u0495\5\u0100\u0081\2\u0494\u0493\3\2\2\2\u0494\u0495\3\2\2\2\u0495\u0496" + - "\3\2\2\2\u0496\u0497\7>\2\2\u0497\u00b9\3\2\2\2\u0498\u049a\5,\27\2\u0499" + - "\u0498\3\2\2\2\u0499\u049a\3\2\2\2\u049a\u049b\3\2\2\2\u049b\u049c\7-" + - "\2\2\u049c\u049e\7;\2\2\u049d\u049f\5\u0190\u00c9\2\u049e\u049d\3\2\2" + - "\2\u049e\u049f\3\2\2\2\u049f\u04a0\3\2\2\2\u04a0\u04a1\7<\2\2\u04a1\u04c7" + - "\7A\2\2\u04a2\u04a4\5,\27\2\u04a3\u04a2\3\2\2\2\u04a3\u04a4\3\2\2\2\u04a4" + - "\u04a5\3\2\2\2\u04a5\u04a6\7*\2\2\u04a6\u04a8\7;\2\2\u04a7\u04a9\5\u0190" + - "\u00c9\2\u04a8\u04a7\3\2\2\2\u04a8\u04a9\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa" + - "\u04ab\7<\2\2\u04ab\u04c7\7A\2\2\u04ac\u04ad\5<\37\2\u04ad\u04af\7C\2" + - "\2\u04ae\u04b0\5,\27\2\u04af\u04ae\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0\u04b1" + - "\3\2\2\2\u04b1\u04b2\7*\2\2\u04b2\u04b4\7;\2\2\u04b3\u04b5\5\u0190\u00c9" + - "\2\u04b4\u04b3\3\2\2\2\u04b4\u04b5\3\2\2\2\u04b5\u04b6\3\2\2\2\u04b6\u04b7" + - "\7<\2\2\u04b7\u04b8\7A\2\2\u04b8\u04c7\3\2\2\2\u04b9\u04ba\5\u0162\u00b2" + - "\2\u04ba\u04bc\7C\2\2\u04bb\u04bd\5,\27\2\u04bc\u04bb\3\2\2\2\u04bc\u04bd" + - "\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04bf\7*\2\2\u04bf\u04c1\7;\2\2\u04c0" + - "\u04c2\5\u0190\u00c9\2\u04c1\u04c0\3\2\2\2\u04c1\u04c2\3\2\2\2\u04c2\u04c3" + - "\3\2\2\2\u04c3\u04c4\7<\2\2\u04c4\u04c5\7A\2\2\u04c5\u04c7\3\2\2\2\u04c6" + - "\u0499\3\2\2\2\u04c6\u04a3\3\2\2\2\u04c6\u04ac\3\2\2\2\u04c6\u04b9\3\2" + - "\2\2\u04c7\u00bb\3\2\2\2\u04c8\u04ca\5X-\2\u04c9\u04c8\3\2\2\2\u04ca\u04cd" + - "\3\2\2\2\u04cb\u04c9\3\2\2\2\u04cb\u04cc\3\2\2\2\u04cc\u04ce\3\2\2\2\u04cd" + - "\u04cb\3\2\2\2\u04ce\u04cf\7\22\2\2\u04cf\u04d1\7h\2\2\u04d0\u04d2\5`" + - "\61\2\u04d1\u04d0\3\2\2\2\u04d1\u04d2\3\2\2\2\u04d2\u04d3\3\2\2\2\u04d3" + - "\u04d4\5\u00be`\2\u04d4\u00bd\3\2\2\2\u04d5\u04d7\7=\2\2\u04d6\u04d8\5" + - "\u00c0a\2\u04d7\u04d6\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8\u04da\3\2\2\2" + - "\u04d9\u04db\7B\2\2\u04da\u04d9\3\2\2\2\u04da\u04db\3\2\2\2\u04db\u04dd" + - "\3\2\2\2\u04dc\u04de\5\u00c6d\2\u04dd\u04dc\3\2\2\2\u04dd\u04de\3\2\2" + - "\2\u04de\u04df\3\2\2\2\u04df\u04e0\7>\2\2\u04e0\u00bf\3\2\2\2\u04e1\u04e6" + - "\5\u00c2b\2\u04e2\u04e3\7B\2\2\u04e3\u04e5\5\u00c2b\2\u04e4\u04e2\3\2" + - "\2\2\u04e5\u04e8\3\2\2\2\u04e6\u04e4\3\2\2\2\u04e6\u04e7\3\2\2\2\u04e7" + - "\u00c1\3\2\2\2\u04e8\u04e6\3\2\2\2\u04e9\u04eb\5\u00c4c\2\u04ea\u04e9" + - "\3\2\2\2\u04eb\u04ee\3\2\2\2\u04ec\u04ea\3\2\2\2\u04ec\u04ed\3\2\2\2\u04ed" + - "\u04ef\3\2\2\2\u04ee\u04ec\3\2\2\2\u04ef\u04f5\7h\2\2\u04f0\u04f2\7;\2" + - "\2\u04f1\u04f3\5\u0190\u00c9\2\u04f2\u04f1\3\2\2\2\u04f2\u04f3\3\2\2\2" + - "\u04f3\u04f4\3\2\2\2\u04f4\u04f6\7<\2\2\u04f5\u04f0\3\2\2\2\u04f5\u04f6" + - "\3\2\2\2\u04f6\u04f8\3\2\2\2\u04f7\u04f9\5d\63\2\u04f8\u04f7\3\2\2\2\u04f8" + - "\u04f9\3\2\2\2\u04f9\u00c3\3\2\2\2\u04fa\u04fb\5\u00e8u\2\u04fb\u00c5" + - "\3\2\2\2\u04fc\u0500\7A\2\2\u04fd\u04ff\5f\64\2\u04fe\u04fd\3\2\2\2\u04ff" + - "\u0502\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u0501\3\2\2\2\u0501\u00c7\3\2" + - "\2\2\u0502\u0500\3\2\2\2\u0503\u0506\5\u00caf\2\u0504\u0506\5\u00dco\2" + - "\u0505\u0503\3\2\2\2\u0505\u0504\3\2\2\2\u0506\u00c9\3\2\2\2\u0507\u0509" + - "\5\u00ccg\2\u0508\u0507\3\2\2\2\u0509\u050c\3\2\2\2\u050a\u0508\3\2\2" + - "\2\u050a\u050b\3\2\2\2\u050b\u050d\3\2\2\2\u050c\u050a\3\2\2\2\u050d\u050e" + - "\7\36\2\2\u050e\u0510\7h\2\2\u050f\u0511\5Z.\2\u0510\u050f\3\2\2\2\u0510" + - "\u0511\3\2\2\2\u0511\u0513\3\2\2\2\u0512\u0514\5\u00ceh\2\u0513\u0512" + - "\3\2\2\2\u0513\u0514\3\2\2\2\u0514\u0515\3\2\2\2\u0515\u0516\5\u00d0i" + - "\2\u0516\u00cb\3\2\2\2\u0517\u051f\5\u00e8u\2\u0518\u051f\7%\2\2\u0519" + - "\u051f\7$\2\2\u051a\u051f\7#\2\2\u051b\u051f\7\3\2\2\u051c\u051f\7(\2" + - "\2\u051d\u051f\7)\2\2\u051e\u0517\3\2\2\2\u051e\u0518\3\2\2\2\u051e\u0519" + - "\3\2\2\2\u051e\u051a\3\2\2\2\u051e\u051b\3\2\2\2\u051e\u051c\3\2\2\2\u051e" + - "\u051d\3\2\2\2\u051f\u00cd\3\2\2\2\u0520\u0521\7\23\2\2\u0521\u0522\5" + - "b\62\2\u0522\u00cf\3\2\2\2\u0523\u0527\7=\2\2\u0524\u0526\5\u00d2j\2\u0525" + - "\u0524\3\2\2\2\u0526\u0529\3\2\2\2\u0527\u0525\3\2\2\2\u0527\u0528\3\2" + - "\2\2\u0528\u052a\3\2\2\2\u0529\u0527\3\2\2\2\u052a\u052b\7>\2\2\u052b" + - "\u00d1\3\2\2\2\u052c\u0532\5\u00d4k\2\u052d\u0532\5\u00d8m\2\u052e\u0532" + - "\5T+\2\u052f\u0532\5\u00c8e\2\u0530\u0532\7A\2\2\u0531\u052c\3\2\2\2\u0531" + - "\u052d\3\2\2\2\u0531\u052e\3\2\2\2\u0531\u052f\3\2\2\2\u0531\u0530\3\2" + - "\2\2\u0532\u00d3\3\2\2\2\u0533\u0535\5\u00d6l\2\u0534\u0533\3\2\2\2\u0535" + - "\u0538\3\2\2\2\u0536\u0534\3\2\2\2\u0536\u0537\3\2\2\2\u0537\u0539\3\2" + - "\2\2\u0538\u0536\3\2\2\2\u0539\u053a\5v<\2\u053a\u053b\5n8\2\u053b\u053c" + - "\7A\2\2\u053c\u00d5\3\2\2\2\u053d\u0542\5\u00e8u\2\u053e\u0542\7%\2\2" + - "\u053f\u0542\7(\2\2\u0540\u0542\7\24\2\2\u0541\u053d\3\2\2\2\u0541\u053e" + - "\3\2\2\2\u0541\u053f\3\2\2\2\u0541\u0540\3\2\2\2\u0542\u00d7\3\2\2\2\u0543" + - "\u0545\5\u00dan\2\u0544\u0543\3\2\2\2\u0545\u0548\3\2\2\2\u0546\u0544" + - "\3\2\2\2\u0546\u0547\3\2\2\2\u0547\u0549\3\2\2\2\u0548\u0546\3\2\2\2\u0549" + - "\u054a\5\u0092J\2\u054a\u054b\5\u00aaV\2\u054b\u00d9\3\2\2\2\u054c\u0553" + - "\5\u00e8u\2\u054d\u0553\7%\2\2\u054e\u0553\7\3\2\2\u054f\u0553\7\16\2" + - "\2\u0550\u0553\7(\2\2\u0551\u0553\7)\2\2\u0552\u054c\3\2\2\2\u0552\u054d" + - "\3\2\2\2\u0552\u054e\3\2\2\2\u0552\u054f\3\2\2\2\u0552\u0550\3\2\2\2\u0552" + - "\u0551\3\2\2\2\u0553\u00db\3\2\2\2\u0554\u0556\5\u00ccg\2\u0555\u0554" + - "\3\2\2\2\u0556\u0559\3\2\2\2\u0557\u0555\3\2\2\2\u0557\u0558\3\2\2\2\u0558" + - "\u055a\3\2\2\2\u0559\u0557\3\2\2\2\u055a\u055b\7i\2\2\u055b\u055c\7\36" + - "\2\2\u055c\u055d\7h\2\2\u055d\u055e\5\u00dep\2\u055e\u00dd\3\2\2\2\u055f" + - "\u0563\7=\2\2\u0560\u0562\5\u00e0q\2\u0561\u0560\3\2\2\2\u0562\u0565\3" + - "\2\2\2\u0563\u0561\3\2\2\2\u0563\u0564\3\2\2\2\u0564\u0566\3\2\2\2\u0565" + - "\u0563\3\2\2\2\u0566\u0567\7>\2\2\u0567\u00df\3\2\2\2\u0568\u056e\5\u00e2" + - "r\2\u0569\u056e\5\u00d4k\2\u056a\u056e\5T+\2\u056b\u056e\5\u00c8e\2\u056c" + - "\u056e\7A\2\2\u056d\u0568\3\2\2\2\u056d\u0569\3\2\2\2\u056d\u056a\3\2" + - "\2\2\u056d\u056b\3\2\2\2\u056d\u056c\3\2\2\2\u056e\u00e1\3\2\2\2\u056f" + - "\u0571\5\u00e4s\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2\2\2\u0572\u0570" + - "\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574\u0572\3\2\2\2\u0575" + - "\u0576\5v<\2\u0576\u0577\7h\2\2\u0577\u0578\7;\2\2\u0578\u057a\7<\2\2" + - "\u0579\u057b\5\"\22\2\u057a\u0579\3\2\2\2\u057a\u057b\3\2\2\2\u057b\u057d" + - "\3\2\2\2\u057c\u057e\5\u00e6t\2\u057d\u057c\3\2\2\2\u057d\u057e\3\2\2" + - "\2\u057e\u057f\3\2\2\2\u057f\u0580\7A\2\2\u0580\u00e3\3\2\2\2\u0581\u0585" + - "\5\u00e8u\2\u0582\u0585\7%\2\2\u0583\u0585\7\3\2\2\u0584\u0581\3\2\2\2" + - "\u0584\u0582\3\2\2\2\u0584\u0583\3\2\2\2\u0585\u00e5\3\2\2\2\u0586\u0587" + - "\7\16\2\2\u0587\u0588\5\u00f0y\2\u0588\u00e7\3\2\2\2\u0589\u058d\5\u00ea" + - "v\2\u058a\u058d\5\u00f6|\2\u058b\u058d\5\u00f8}\2\u058c\u0589\3\2\2\2" + - "\u058c\u058a\3\2\2\2\u058c\u058b\3\2\2\2\u058d\u00e9\3\2\2\2\u058e\u058f" + - "\7i\2\2\u058f\u0590\58\35\2\u0590\u0592\7;\2\2\u0591\u0593\5\u00ecw\2" + - "\u0592\u0591\3\2\2\2\u0592\u0593\3\2\2\2\u0593\u0594\3\2\2\2\u0594\u0595" + - "\7<\2\2\u0595\u00eb\3\2\2\2\u0596\u059b\5\u00eex\2\u0597\u0598\7B\2\2" + - "\u0598\u059a\5\u00eex\2\u0599\u0597\3\2\2\2\u059a\u059d\3\2\2\2\u059b" + - "\u0599\3\2\2\2\u059b\u059c\3\2\2\2\u059c\u00ed\3\2\2\2\u059d\u059b\3\2" + - "\2\2\u059e\u059f\7h\2\2\u059f\u05a0\7D\2\2\u05a0\u05a1\5\u00f0y\2\u05a1" + - "\u00ef\3\2\2\2\u05a2\u05a6\5\u01b2\u00da\2\u05a3\u05a6\5\u00f2z\2\u05a4" + - "\u05a6\5\u00e8u\2\u05a5\u05a2\3\2\2\2\u05a5\u05a3\3\2\2\2\u05a5\u05a4" + - "\3\2\2\2\u05a6\u00f1\3\2\2\2\u05a7\u05a9\7=\2\2\u05a8\u05aa\5\u00f4{\2" + - "\u05a9\u05a8\3\2\2\2\u05a9\u05aa\3\2\2\2\u05aa\u05ac\3\2\2\2\u05ab\u05ad" + - "\7B\2\2\u05ac\u05ab\3\2\2\2\u05ac\u05ad\3\2\2\2\u05ad\u05ae\3\2\2\2\u05ae" + - "\u05af\7>\2\2\u05af\u00f3\3\2\2\2\u05b0\u05b5\5\u00f0y\2\u05b1\u05b2\7" + - "B\2\2\u05b2\u05b4\5\u00f0y\2\u05b3\u05b1\3\2\2\2\u05b4\u05b7\3\2\2\2\u05b5" + - "\u05b3\3\2\2\2\u05b5\u05b6\3\2\2\2\u05b6\u00f5\3\2\2\2\u05b7\u05b5\3\2" + - "\2\2\u05b8\u05b9\7i\2\2\u05b9\u05ba\58\35\2\u05ba\u00f7\3\2\2\2\u05bb" + - "\u05bc\7i\2\2\u05bc\u05bd\58\35\2\u05bd\u05be\7;\2\2\u05be\u05bf\5\u00f0" + - "y\2\u05bf\u05c0\7<\2\2\u05c0\u00f9\3\2\2\2\u05c1\u05c3\7=\2\2\u05c2\u05c4" + - "\5\u00fc\177\2\u05c3\u05c2\3\2\2\2\u05c3\u05c4\3\2\2\2\u05c4\u05c6\3\2" + - "\2\2\u05c5\u05c7\7B\2\2\u05c6\u05c5\3\2\2\2\u05c6\u05c7\3\2\2\2\u05c7" + - "\u05c8\3\2\2\2\u05c8\u05c9\7>\2\2\u05c9\u00fb\3\2\2\2\u05ca\u05cf\5t;" + - "\2\u05cb\u05cc\7B\2\2\u05cc\u05ce\5t;\2\u05cd\u05cb\3\2\2\2\u05ce\u05d1" + - "\3\2\2\2\u05cf\u05cd\3\2\2\2\u05cf\u05d0\3\2\2\2\u05d0\u00fd\3\2\2\2\u05d1" + - "\u05cf\3\2\2\2\u05d2\u05d4\7=\2\2\u05d3\u05d5\5\u0100\u0081\2\u05d4\u05d3" + - "\3\2\2\2\u05d4\u05d5\3\2\2\2\u05d5\u05d6\3\2\2\2\u05d6\u05d7\7>\2\2\u05d7" + - "\u00ff\3\2\2\2\u05d8\u05dc\5\u0102\u0082\2\u05d9\u05db\5\u0102\u0082\2" + - "\u05da\u05d9\3\2\2\2\u05db\u05de\3\2\2\2\u05dc\u05da\3\2\2\2\u05dc\u05dd" + - "\3\2\2\2\u05dd\u0101\3\2\2\2\u05de\u05dc\3\2\2\2\u05df\u05e3\5\u0104\u0083" + - "\2\u05e0\u05e3\5T+\2\u05e1\u05e3\5\u0108\u0085\2\u05e2\u05df\3\2\2\2\u05e2" + - "\u05e0\3\2\2\2\u05e2\u05e1\3\2\2\2\u05e3\u0103\3\2\2\2\u05e4\u05e5\5\u0106" + - "\u0084\2\u05e5\u05e6\7A\2\2\u05e6\u0105\3\2\2\2\u05e7\u05e9\5\u009eP\2" + - "\u05e8\u05e7\3\2\2\2\u05e9\u05ec\3\2\2\2\u05ea\u05e8\3\2\2\2\u05ea\u05eb" + - "\3\2\2\2\u05eb\u05ed\3\2\2\2\u05ec\u05ea\3\2\2\2\u05ed\u05ee\5v<\2\u05ee" + - "\u05ef\5n8\2\u05ef\u0107\3\2\2\2\u05f0\u05f7\5\u010c\u0087\2\u05f1\u05f7" + - "\5\u0110\u0089\2\u05f2\u05f7\5\u0118\u008d\2\u05f3\u05f7\5\u011a\u008e" + - "\2\u05f4\u05f7\5\u012c\u0097\2\u05f5\u05f7\5\u0132\u009a\2\u05f6\u05f0" + - "\3\2\2\2\u05f6\u05f1\3\2\2\2\u05f6\u05f2\3\2\2\2\u05f6\u05f3\3\2\2\2\u05f6" + - "\u05f4\3\2\2\2\u05f6\u05f5\3\2\2\2\u05f7\u0109\3\2\2\2\u05f8\u05fe\5\u010c" + - "\u0087\2\u05f9\u05fe\5\u0112\u008a\2\u05fa\u05fe\5\u011c\u008f\2\u05fb" + - "\u05fe\5\u012e\u0098\2\u05fc\u05fe\5\u0134\u009b\2\u05fd\u05f8\3\2\2\2" + - "\u05fd\u05f9\3\2\2\2\u05fd\u05fa\3\2\2\2\u05fd\u05fb\3\2\2\2\u05fd\u05fc" + - "\3\2\2\2\u05fe\u010b\3\2\2\2\u05ff\u060c\5\u00fe\u0080\2\u0600\u060c\5" + - "\u010e\u0088\2\u0601\u060c\5\u0114\u008b\2\u0602\u060c\5\u011e\u0090\2" + - "\u0603\u060c\5\u0120\u0091\2\u0604\u060c\5\u0130\u0099\2\u0605\u060c\5" + - "\u0144\u00a3\2\u0606\u060c\5\u0146\u00a4\2\u0607\u060c\5\u0148\u00a5\2" + - "\u0608\u060c\5\u014c\u00a7\2\u0609\u060c\5\u014a\u00a6\2\u060a\u060c\5" + - "\u014e\u00a8\2\u060b\u05ff\3\2\2\2\u060b\u0600\3\2\2\2\u060b\u0601\3\2" + - "\2\2\u060b\u0602\3\2\2\2\u060b\u0603\3\2\2\2\u060b\u0604\3\2\2\2\u060b" + - "\u0605\3\2\2\2\u060b\u0606\3\2\2\2\u060b\u0607\3\2\2\2\u060b\u0608\3\2" + - "\2\2\u060b\u0609\3\2\2\2\u060b\u060a\3\2\2\2\u060c\u010d\3\2\2\2\u060d" + - "\u060e\7A\2\2\u060e\u010f\3\2\2\2\u060f\u0610\7h\2\2\u0610\u0611\7J\2" + - "\2\u0611\u0612\5\u0108\u0085\2\u0612\u0111\3\2\2\2\u0613\u0614\7h\2\2" + - "\u0614\u0615\7J\2\2\u0615\u0616\5\u010a\u0086\2\u0616\u0113\3\2\2\2\u0617" + - "\u0618\5\u0116\u008c\2\u0618\u0619\7A\2\2\u0619\u0115\3\2\2\2\u061a\u0622" + - "\5\u01ac\u00d7\2\u061b\u0622\5\u01ca\u00e6\2\u061c\u0622\5\u01cc\u00e7" + - "\2\u061d\u0622\5\u01d2\u00ea\2\u061e\u0622\5\u01d6\u00ec\2\u061f\u0622" + - "\5\u018a\u00c6\2\u0620\u0622\5\u0176\u00bc\2\u0621\u061a\3\2\2\2\u0621" + - "\u061b\3\2\2\2\u0621\u061c\3\2\2\2\u0621\u061d\3\2\2\2\u0621\u061e\3\2" + - "\2\2\u0621\u061f\3\2\2\2\u0621\u0620\3\2\2\2\u0622\u0117\3\2\2\2\u0623" + - "\u0624\7\30\2\2\u0624\u0625\7;\2\2\u0625\u0626\5\u01a0\u00d1\2\u0626\u0627" + - "\7<\2\2\u0627\u0628\5\u0108\u0085\2\u0628\u0119\3\2\2\2\u0629\u062a\7" + - "\30\2\2\u062a\u062b\7;\2\2\u062b\u062c\5\u01a0\u00d1\2\u062c\u062d\7<" + - "\2\2\u062d\u062e\5\u010a\u0086\2\u062e\u062f\7\21\2\2\u062f\u0630\5\u0108" + - "\u0085\2\u0630\u011b\3\2\2\2\u0631\u0632\7\30\2\2\u0632\u0633\7;\2\2\u0633" + - "\u0634\5\u01a0\u00d1\2\u0634\u0635\7<\2\2\u0635\u0636\5\u010a\u0086\2" + - "\u0636\u0637\7\21\2\2\u0637\u0638\5\u010a\u0086\2\u0638\u011d\3\2\2\2" + - "\u0639\u063a\7\4\2\2\u063a\u063b\5\u01a0\u00d1\2\u063b\u063c\7A\2\2\u063c" + - "\u0644\3\2\2\2\u063d\u063e\7\4\2\2\u063e\u063f\5\u01a0\u00d1\2\u063f\u0640" + - "\7J\2\2\u0640\u0641\5\u01a0\u00d1\2\u0641\u0642\7A\2\2\u0642\u0644\3\2" + - "\2\2\u0643\u0639\3\2\2\2\u0643\u063d\3\2\2\2\u0644\u011f\3\2\2\2\u0645" + - "\u0646\7+\2\2\u0646\u0647\7;\2\2\u0647\u0648\5\u01a0\u00d1\2\u0648\u0649" + - "\7<\2\2\u0649\u064a\5\u0122\u0092\2\u064a\u0121\3\2\2\2\u064b\u064f\7" + - "=\2\2\u064c\u064e\5\u0124\u0093\2\u064d\u064c\3\2\2\2\u064e\u0651\3\2" + - "\2\2\u064f\u064d\3\2\2\2\u064f\u0650\3\2\2\2\u0650\u0655\3\2\2\2\u0651" + - "\u064f\3\2\2\2\u0652\u0654\5\u0128\u0095\2\u0653\u0652\3\2\2\2\u0654\u0657" + - "\3\2\2\2\u0655\u0653\3\2\2\2\u0655\u0656\3\2\2\2\u0656\u0658\3\2\2\2\u0657" + - "\u0655\3\2\2\2\u0658\u0659\7>\2\2\u0659\u0123\3\2\2\2\u065a\u065b\5\u0126" + - "\u0094\2\u065b\u065c\5\u0100\u0081\2\u065c\u0125\3\2\2\2\u065d\u0661\5" + - "\u0128\u0095\2\u065e\u0660\5\u0128\u0095\2\u065f\u065e\3\2\2\2\u0660\u0663" + - "\3\2\2\2\u0661\u065f\3\2\2\2\u0661\u0662\3\2\2\2\u0662\u0127\3\2\2\2\u0663" + - "\u0661\3\2\2\2\u0664\u0665\7\b\2\2\u0665\u0666\5\u019e\u00d0\2\u0666\u0667" + - "\7J\2\2\u0667\u066f\3\2\2\2\u0668\u0669\7\b\2\2\u0669\u066a\5\u012a\u0096" + - "\2\u066a\u066b\7J\2\2\u066b\u066f\3\2\2\2\u066c\u066d\7\16\2\2\u066d\u066f" + - "\7J\2\2\u066e\u0664\3\2\2\2\u066e\u0668\3\2\2\2\u066e\u066c\3\2\2\2\u066f" + - "\u0129\3\2\2\2\u0670\u0671\7h\2\2\u0671\u012b\3\2\2\2\u0672\u0673\7\64" + - "\2\2\u0673\u0674\7;\2\2\u0674\u0675\5\u01a0\u00d1\2\u0675\u0676\7<\2\2" + - "\u0676\u0677\5\u0108\u0085\2\u0677\u012d\3\2\2\2\u0678\u0679\7\64\2\2" + - "\u0679\u067a\7;\2\2\u067a\u067b\5\u01a0\u00d1\2\u067b\u067c\7<\2\2\u067c" + - "\u067d\5\u010a\u0086\2\u067d\u012f\3\2\2\2\u067e\u067f\7\17\2\2\u067f" + - "\u0680\5\u0108\u0085\2\u0680\u0681\7\64\2\2\u0681\u0682\7;\2\2\u0682\u0683" + - "\5\u01a0\u00d1\2\u0683\u0684\7<\2\2\u0684\u0685\7A\2\2\u0685\u0131\3\2" + - "\2\2\u0686\u0689\5\u0136\u009c\2\u0687\u0689\5\u0140\u00a1\2\u0688\u0686" + - "\3\2\2\2\u0688\u0687\3\2\2\2\u0689\u0133\3\2\2\2\u068a\u068d\5\u0138\u009d" + - "\2\u068b\u068d\5\u0142\u00a2\2\u068c\u068a\3\2\2\2\u068c\u068b\3\2\2\2" + - "\u068d\u0135\3\2\2\2\u068e\u068f\7\27\2\2\u068f\u0691\7;\2\2\u0690\u0692" + - "\5\u013a\u009e\2\u0691\u0690\3\2\2\2\u0691\u0692\3\2\2\2\u0692\u0693\3" + - "\2\2\2\u0693\u0695\7A\2\2\u0694\u0696\5\u01a0\u00d1\2\u0695\u0694\3\2" + - "\2\2\u0695\u0696\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u0699\7A\2\2\u0698" + - "\u069a\5\u013c\u009f\2\u0699\u0698\3\2\2\2\u0699\u069a\3\2\2\2\u069a\u069b" + - "\3\2\2\2\u069b\u069c\7<\2\2\u069c\u069d\5\u0108\u0085\2\u069d\u0137\3" + - "\2\2\2\u069e\u069f\7\27\2\2\u069f\u06a1\7;\2\2\u06a0\u06a2\5\u013a\u009e" + - "\2\u06a1\u06a0\3\2\2\2\u06a1\u06a2\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3\u06a5" + - "\7A\2\2\u06a4\u06a6\5\u01a0\u00d1\2\u06a5\u06a4\3\2\2\2\u06a5\u06a6\3" + - "\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u06a9\7A\2\2\u06a8\u06aa\5\u013c\u009f" + - "\2\u06a9\u06a8\3\2\2\2\u06a9\u06aa\3\2\2\2\u06aa\u06ab\3\2\2\2\u06ab\u06ac" + - "\7<\2\2\u06ac\u06ad\5\u010a\u0086\2\u06ad\u0139\3\2\2\2\u06ae\u06b1\5" + - "\u013e\u00a0\2\u06af\u06b1\5\u0106\u0084\2\u06b0\u06ae\3\2\2\2\u06b0\u06af" + - "\3\2\2\2\u06b1\u013b\3\2\2\2\u06b2\u06b3\5\u013e\u00a0\2\u06b3\u013d\3" + - "\2\2\2\u06b4\u06b9\5\u0116\u008c\2\u06b5\u06b6\7B\2\2\u06b6\u06b8\5\u0116" + - "\u008c\2\u06b7\u06b5\3\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9" + - "\u06ba\3\2\2\2\u06ba\u013f\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06bd\7\27" + - "\2\2\u06bd\u06c1\7;\2\2\u06be\u06c0\5\u009eP\2\u06bf\u06be\3\2\2\2\u06c0" + - "\u06c3\3\2\2\2\u06c1\u06bf\3\2\2\2\u06c1\u06c2\3\2\2\2\u06c2\u06c4\3\2" + - "\2\2\u06c3\u06c1\3\2\2\2\u06c4\u06c5\5v<\2\u06c5\u06c6\5r:\2\u06c6\u06c7" + - "\7J\2\2\u06c7\u06c8\5\u01a0\u00d1\2\u06c8\u06c9\7<\2\2\u06c9\u06ca\5\u0108" + - "\u0085\2\u06ca\u0141\3\2\2\2\u06cb\u06cc\7\27\2\2\u06cc\u06d0\7;\2\2\u06cd" + - "\u06cf\5\u009eP\2\u06ce\u06cd\3\2\2\2\u06cf\u06d2\3\2\2\2\u06d0\u06ce" + - "\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1\u06d3\3\2\2\2\u06d2\u06d0\3\2\2\2\u06d3" + - "\u06d4\5v<\2\u06d4\u06d5\5r:\2\u06d5\u06d6\7J\2\2\u06d6\u06d7\5\u01a0" + - "\u00d1\2\u06d7\u06d8\7<\2\2\u06d8\u06d9\5\u010a\u0086\2\u06d9\u0143\3" + - "\2\2\2\u06da\u06dc\7\6\2\2\u06db\u06dd\7h\2\2\u06dc\u06db\3\2\2\2\u06dc" + - "\u06dd\3\2\2\2\u06dd\u06de\3\2\2\2\u06de\u06df\7A\2\2\u06df\u0145\3\2" + - "\2\2\u06e0\u06e2\7\r\2\2\u06e1\u06e3\7h\2\2\u06e2\u06e1\3\2\2\2\u06e2" + - "\u06e3\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u06e5\7A\2\2\u06e5\u0147\3\2" + - "\2\2\u06e6\u06e8\7&\2\2\u06e7\u06e9\5\u01a0\u00d1\2\u06e8\u06e7\3\2\2" + - "\2\u06e8\u06e9\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06eb\7A\2\2\u06eb\u0149" + - "\3\2\2\2\u06ec\u06ed\7.\2\2\u06ed\u06ee\5\u01a0\u00d1\2\u06ee\u06ef\7" + - "A\2\2\u06ef\u014b\3\2\2\2\u06f0\u06f1\7,\2\2\u06f1\u06f2\7;\2\2\u06f2" + - "\u06f3\5\u01a0\u00d1\2\u06f3\u06f4\7<\2\2\u06f4\u06f5\5\u00fe\u0080\2" + - "\u06f5\u014d\3\2\2\2\u06f6\u06f7\7\61\2\2\u06f7\u06f8\5\u00fe\u0080\2" + - "\u06f8\u06f9\5\u0150\u00a9\2\u06f9\u0703\3\2\2\2\u06fa\u06fb\7\61\2\2" + - "\u06fb\u06fd\5\u00fe\u0080\2\u06fc\u06fe\5\u0150\u00a9\2\u06fd\u06fc\3" + - "\2\2\2\u06fd\u06fe\3\2\2\2\u06fe\u06ff\3\2\2\2\u06ff\u0700\5\u0158\u00ad" + - "\2\u0700\u0703\3\2\2\2\u0701\u0703\5\u015a\u00ae\2\u0702\u06f6\3\2\2\2" + - "\u0702\u06fa\3\2\2\2\u0702\u0701\3\2\2\2\u0703\u014f\3\2\2\2\u0704\u0708" + - "\5\u0152\u00aa\2\u0705\u0707\5\u0152\u00aa\2\u0706\u0705\3\2\2\2\u0707" + - "\u070a\3\2\2\2\u0708\u0706\3\2\2\2\u0708\u0709\3\2\2\2\u0709\u0151\3\2" + - "\2\2\u070a\u0708\3\2\2\2\u070b\u070c\7\t\2\2\u070c\u070d\7;\2\2\u070d" + - "\u070e\5\u0154\u00ab\2\u070e\u070f\7<\2\2\u070f\u0710\5\u00fe\u0080\2" + - "\u0710\u0153\3\2\2\2\u0711\u0713\5\u009eP\2\u0712\u0711\3\2\2\2\u0713" + - "\u0716\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0715\3\2\2\2\u0715\u0717\3\2" + - "\2\2\u0716\u0714\3\2\2\2\u0717\u0718\5\u0156\u00ac\2\u0718\u0719\5r:\2" + - "\u0719\u0155\3\2\2\2\u071a\u071f\5~@\2\u071b\u071c\7X\2\2\u071c\u071e" + - "\5\22\n\2\u071d\u071b\3\2\2\2\u071e\u0721\3\2\2\2\u071f\u071d\3\2\2\2" + - "\u071f\u0720\3\2\2\2\u0720\u0157\3\2\2\2\u0721\u071f\3\2\2\2\u0722\u0723" + - "\7\25\2\2\u0723\u0724\5\u00fe\u0080\2\u0724\u0159\3\2\2\2\u0725\u0726" + - "\7\61\2\2\u0726\u0727\5\u015c\u00af\2\u0727\u0729\5\u00fe\u0080\2\u0728" + - "\u072a\5\u0150\u00a9\2\u0729\u0728\3\2\2\2\u0729\u072a\3\2\2\2\u072a\u072c" + - "\3\2\2\2\u072b\u072d\5\u0158\u00ad\2\u072c\u072b\3\2\2\2\u072c\u072d\3" + - "\2\2\2\u072d\u015b\3\2\2\2\u072e\u072f\7;\2\2\u072f\u0731\5\u015e\u00b0" + - "\2\u0730\u0732\7A\2\2\u0731\u0730\3\2\2\2\u0731\u0732\3\2\2\2\u0732\u0733" + - "\3\2\2\2\u0733\u0734\7<\2\2\u0734\u015d\3\2\2\2\u0735\u073a\5\u0160\u00b1" + - "\2\u0736\u0737\7A\2\2\u0737\u0739\5\u0160\u00b1\2\u0738\u0736\3\2\2\2" + - "\u0739\u073c\3\2\2\2\u073a\u0738\3\2\2\2\u073a\u073b\3\2\2\2\u073b\u015f" + - "\3\2\2\2\u073c\u073a\3\2\2\2\u073d\u073f\5\u009eP\2\u073e\u073d\3\2\2" + - "\2\u073f\u0742\3\2\2\2\u0740\u073e\3\2\2\2\u0740\u0741\3\2\2\2\u0741\u0743" + - "\3\2\2\2\u0742\u0740\3\2\2\2\u0743\u0744\5v<\2\u0744\u0745\5r:\2\u0745" + - "\u0746\7D\2\2\u0746\u0747\5\u01a0\u00d1\2\u0747\u0161\3\2\2\2\u0748\u074b" + - "\5\u0170\u00b9\2\u0749\u074b\5\u0198\u00cd\2\u074a\u0748\3\2\2\2\u074a" + - "\u0749\3\2\2\2\u074b\u074f\3\2\2\2\u074c\u074e\5\u016a\u00b6\2\u074d\u074c" + - "\3\2\2\2\u074e\u0751\3\2\2\2\u074f\u074d\3\2\2\2\u074f\u0750\3\2\2\2\u0750" + - "\u0163\3\2\2\2\u0751\u074f\3\2\2\2\u0752\u0770\5\2\2\2\u0753\u0758\58" + - "\35\2\u0754\u0755\7?\2\2\u0755\u0757\7@\2\2\u0756\u0754\3\2\2\2\u0757" + - "\u075a\3\2\2\2\u0758\u0756\3\2\2\2\u0758\u0759\3\2\2\2\u0759\u075b\3\2" + - "\2\2\u075a\u0758\3\2\2\2\u075b\u075c\7C\2\2\u075c\u075d\7\13\2\2\u075d" + - "\u0770\3\2\2\2\u075e\u075f\7\62\2\2\u075f\u0760\7C\2\2\u0760\u0770\7\13" + - "\2\2\u0761\u0770\7-\2\2\u0762\u0763\58\35\2\u0763\u0764\7C\2\2\u0764\u0765" + - "\7-\2\2\u0765\u0770\3\2\2\2\u0766\u0767\7;\2\2\u0767\u0768\5\u01a0\u00d1" + - "\2\u0768\u0769\7<\2\2\u0769\u0770\3\2\2\2\u076a\u0770\5\u0176\u00bc\2" + - "\u076b\u0770\5\u017e\u00c0\2\u076c\u0770\5\u0184\u00c3\2\u076d\u0770\5" + - "\u018a\u00c6\2\u076e\u0770\5\u0192\u00ca\2\u076f\u0752\3\2\2\2\u076f\u0753" + - "\3\2\2\2\u076f\u075e\3\2\2\2\u076f\u0761\3\2\2\2\u076f\u0762\3\2\2\2\u076f" + - "\u0766\3\2\2\2\u076f\u076a\3\2\2\2\u076f\u076b\3\2\2\2\u076f\u076c\3\2" + - "\2\2\u076f\u076d\3\2\2\2\u076f\u076e\3\2\2\2\u0770\u0165\3\2\2\2\u0771" + - "\u0772\3\2\2\2\u0772\u0167\3\2\2\2\u0773\u0790\5\2\2\2\u0774\u0779\58" + - "\35\2\u0775\u0776\7?\2\2\u0776\u0778\7@\2\2\u0777\u0775\3\2\2\2\u0778" + - "\u077b\3\2\2\2\u0779\u0777\3\2\2\2\u0779\u077a\3\2\2\2\u077a\u077c\3\2" + - "\2\2\u077b\u0779\3\2\2\2\u077c\u077d\7C\2\2\u077d\u077e\7\13\2\2\u077e" + - "\u0790\3\2\2\2\u077f\u0780\7\62\2\2\u0780\u0781\7C\2\2\u0781\u0790\7\13" + - "\2\2\u0782\u0790\7-\2\2\u0783\u0784\58\35\2\u0784\u0785\7C\2\2\u0785\u0786" + - "\7-\2\2\u0786\u0790\3\2\2\2\u0787\u0788\7;\2\2\u0788\u0789\5\u01a0\u00d1" + - "\2\u0789\u078a\7<\2\2\u078a\u0790\3\2\2\2\u078b\u0790\5\u0176\u00bc\2" + - "\u078c\u0790\5\u017e\u00c0\2\u078d\u0790\5\u018a\u00c6\2\u078e\u0790\5" + - "\u0192\u00ca\2\u078f\u0773\3\2\2\2\u078f\u0774\3\2\2\2\u078f\u077f\3\2" + - "\2\2\u078f\u0782\3\2\2\2\u078f\u0783\3\2\2\2\u078f\u0787\3\2\2\2\u078f" + - "\u078b\3\2\2\2\u078f\u078c\3\2\2\2\u078f\u078d\3\2\2\2\u078f\u078e\3\2" + - "\2\2\u0790\u0169\3\2\2\2\u0791\u0797\5\u0178\u00bd\2\u0792\u0797\5\u0180" + - "\u00c1\2\u0793\u0797\5\u0186\u00c4\2\u0794\u0797\5\u018c\u00c7\2\u0795" + - "\u0797\5\u0194\u00cb\2\u0796\u0791\3\2\2\2\u0796\u0792\3\2\2\2\u0796\u0793" + - "\3\2\2\2\u0796\u0794\3\2\2\2\u0796\u0795\3\2\2\2\u0797\u016b\3\2\2\2\u0798" + - "\u0799\3\2\2\2\u0799\u016d\3\2\2\2\u079a\u079f\5\u0178\u00bd\2\u079b\u079f" + - "\5\u0180\u00c1\2\u079c\u079f\5\u018c\u00c7\2\u079d\u079f\5\u0194\u00cb" + - "\2\u079e\u079a\3\2\2\2\u079e\u079b\3\2\2\2\u079e\u079c\3\2\2\2\u079e\u079d" + - "\3\2\2\2\u079f\u016f\3\2\2\2\u07a0\u07c9\5\2\2\2\u07a1\u07a6\58\35\2\u07a2" + - "\u07a3\7?\2\2\u07a3\u07a5\7@\2\2\u07a4\u07a2\3\2\2\2\u07a5\u07a8\3\2\2" + - "\2\u07a6\u07a4\3\2\2\2\u07a6\u07a7\3\2\2\2\u07a7\u07a9\3\2\2\2\u07a8\u07a6" + - "\3\2\2\2\u07a9\u07aa\7C\2\2\u07aa\u07ab\7\13\2\2\u07ab\u07c9\3\2\2\2\u07ac" + - "\u07b1\5x=\2\u07ad\u07ae\7?\2\2\u07ae\u07b0\7@\2\2\u07af\u07ad\3\2\2\2" + - "\u07b0\u07b3\3\2\2\2\u07b1\u07af\3\2\2\2\u07b1\u07b2\3\2\2\2\u07b2\u07b4" + - "\3\2\2\2\u07b3\u07b1\3\2\2\2\u07b4\u07b5\7C\2\2\u07b5\u07b6\7\13\2\2\u07b6" + - "\u07c9\3\2\2\2\u07b7\u07b8\7\62\2\2\u07b8\u07b9\7C\2\2\u07b9\u07c9\7\13" + - "\2\2\u07ba\u07c9\7-\2\2\u07bb\u07bc\58\35\2\u07bc\u07bd\7C\2\2\u07bd\u07be" + - "\7-\2\2\u07be\u07c9\3\2\2\2\u07bf\u07c0\7;\2\2\u07c0\u07c1\5\u01a0\u00d1" + - "\2\u07c1\u07c2\7<\2\2\u07c2\u07c9\3\2\2\2\u07c3\u07c9\5\u017a\u00be\2" + - "\u07c4\u07c9\5\u0182\u00c2\2\u07c5\u07c9\5\u0188\u00c5\2\u07c6\u07c9\5" + - "\u018e\u00c8\2\u07c7\u07c9\5\u0196\u00cc\2\u07c8\u07a0\3\2\2\2\u07c8\u07a1" + - "\3\2\2\2\u07c8\u07ac\3\2\2\2\u07c8\u07b7\3\2\2\2\u07c8\u07ba\3\2\2\2\u07c8" + - "\u07bb\3\2\2\2\u07c8\u07bf\3\2\2\2\u07c8\u07c3\3\2\2\2\u07c8\u07c4\3\2" + - "\2\2\u07c8\u07c5\3\2\2\2\u07c8\u07c6\3\2\2\2\u07c8\u07c7\3\2\2\2\u07c9" + - "\u0171\3\2\2\2\u07ca\u07cb\3\2\2\2\u07cb\u0173\3\2\2\2\u07cc\u07f4\5\2" + - "\2\2\u07cd\u07d2\58\35\2\u07ce\u07cf\7?\2\2\u07cf\u07d1\7@\2\2\u07d0\u07ce" + - "\3\2\2\2\u07d1\u07d4\3\2\2\2\u07d2\u07d0\3\2\2\2\u07d2\u07d3\3\2\2\2\u07d3" + - "\u07d5\3\2\2\2\u07d4\u07d2\3\2\2\2\u07d5\u07d6\7C\2\2\u07d6\u07d7\7\13" + - "\2\2\u07d7\u07f4\3\2\2\2\u07d8\u07dd\5x=\2\u07d9\u07da\7?\2\2\u07da\u07dc" + - "\7@\2\2\u07db\u07d9\3\2\2\2\u07dc\u07df\3\2\2\2\u07dd\u07db\3\2\2\2\u07dd" + - "\u07de\3\2\2\2\u07de\u07e0\3\2\2\2\u07df\u07dd\3\2\2\2\u07e0\u07e1\7C" + - "\2\2\u07e1\u07e2\7\13\2\2\u07e2\u07f4\3\2\2\2\u07e3\u07e4\7\62\2\2\u07e4" + - "\u07e5\7C\2\2\u07e5\u07f4\7\13\2\2\u07e6\u07f4\7-\2\2\u07e7\u07e8\58\35" + - "\2\u07e8\u07e9\7C\2\2\u07e9\u07ea\7-\2\2\u07ea\u07f4\3\2\2\2\u07eb\u07ec" + - "\7;\2\2\u07ec\u07ed\5\u01a0\u00d1\2\u07ed\u07ee\7<\2\2\u07ee\u07f4\3\2" + - "\2\2\u07ef\u07f4\5\u017a\u00be\2\u07f0\u07f4\5\u0182\u00c2\2\u07f1\u07f4" + - "\5\u018e\u00c8\2\u07f2\u07f4\5\u0196\u00cc\2\u07f3\u07cc\3\2\2\2\u07f3" + - "\u07cd\3\2\2\2\u07f3\u07d8\3\2\2\2\u07f3\u07e3\3\2\2\2\u07f3\u07e6\3\2" + - "\2\2\u07f3\u07e7\3\2\2\2\u07f3\u07eb\3\2\2\2\u07f3\u07ef\3\2\2\2\u07f3" + - "\u07f0\3\2\2\2\u07f3\u07f1\3\2\2\2\u07f3\u07f2\3\2\2\2\u07f4\u0175\3\2" + - "\2\2\u07f5\u07f7\7!\2\2\u07f6\u07f8\5,\27\2\u07f7\u07f6\3\2\2\2\u07f7" + - "\u07f8\3\2\2\2\u07f8\u07fc\3\2\2\2\u07f9\u07fb\5\u00e8u\2\u07fa\u07f9" + - "\3\2\2\2\u07fb\u07fe\3\2\2\2\u07fc\u07fa\3\2\2\2\u07fc\u07fd\3\2\2\2\u07fd" + - "\u07ff\3\2\2\2\u07fe\u07fc\3\2\2\2\u07ff\u080a\7h\2\2\u0800\u0804\7C\2" + - "\2\u0801\u0803\5\u00e8u\2\u0802\u0801\3\2\2\2\u0803\u0806\3\2\2\2\u0804" + - "\u0802\3\2\2\2\u0804\u0805\3\2\2\2\u0805\u0807\3\2\2\2\u0806\u0804\3\2" + - "\2\2\u0807\u0809\7h\2\2\u0808\u0800\3\2\2\2\u0809\u080c\3\2\2\2\u080a" + - "\u0808\3\2\2\2\u080a\u080b\3\2\2\2\u080b\u080e\3\2\2\2\u080c\u080a\3\2" + - "\2\2\u080d\u080f\5\u017c\u00bf\2\u080e\u080d\3\2\2\2\u080e\u080f\3\2\2" + - "\2\u080f\u0810\3\2\2\2\u0810\u0812\7;\2\2\u0811\u0813\5\u0190\u00c9\2" + - "\u0812\u0811\3\2\2\2\u0812\u0813\3\2\2\2\u0813\u0814\3\2\2\2\u0814\u0816" + - "\7<\2\2\u0815\u0817\5d\63\2\u0816\u0815\3\2\2\2\u0816\u0817\3\2\2\2\u0817" + - "\u0849\3\2\2\2\u0818\u0819\5<\37\2\u0819\u081a\7C\2\2\u081a\u081c\7!\2" + - "\2\u081b\u081d\5,\27\2\u081c\u081b\3\2\2\2\u081c\u081d\3\2\2\2\u081d\u0821" + - "\3\2\2\2\u081e\u0820\5\u00e8u\2\u081f\u081e\3\2\2\2\u0820\u0823\3\2\2" + - "\2\u0821\u081f\3\2\2\2\u0821\u0822\3\2\2\2\u0822\u0824\3\2\2\2\u0823\u0821" + - "\3\2\2\2\u0824\u0826\7h\2\2\u0825\u0827\5\u017c\u00bf\2\u0826\u0825\3" + - "\2\2\2\u0826\u0827\3\2\2\2\u0827\u0828\3\2\2\2\u0828\u082a\7;\2\2\u0829" + - "\u082b\5\u0190\u00c9\2\u082a\u0829\3\2\2\2\u082a\u082b\3\2\2\2\u082b\u082c" + - "\3\2\2\2\u082c\u082e\7<\2\2\u082d\u082f\5d\63\2\u082e\u082d\3\2\2\2\u082e" + - "\u082f\3\2\2\2\u082f\u0849\3\2\2\2\u0830\u0831\5\u0162\u00b2\2\u0831\u0832" + - "\7C\2\2\u0832\u0834\7!\2\2\u0833\u0835\5,\27\2\u0834\u0833\3\2\2\2\u0834" + - "\u0835\3\2\2\2\u0835\u0839\3\2\2\2\u0836\u0838\5\u00e8u\2\u0837\u0836" + - "\3\2\2\2\u0838\u083b\3\2\2\2\u0839\u0837\3\2\2\2\u0839\u083a\3\2\2\2\u083a" + - "\u083c\3\2\2\2\u083b\u0839\3\2\2\2\u083c\u083e\7h\2\2\u083d\u083f\5\u017c" + - "\u00bf\2\u083e\u083d\3\2\2\2\u083e\u083f\3\2\2\2\u083f\u0840\3\2\2\2\u0840" + - "\u0842\7;\2\2\u0841\u0843\5\u0190\u00c9\2\u0842\u0841\3\2\2\2\u0842\u0843" + - "\3\2\2\2\u0843\u0844\3\2\2\2\u0844\u0846\7<\2\2\u0845\u0847\5d\63\2\u0846" + - "\u0845\3\2\2\2\u0846\u0847\3\2\2\2\u0847\u0849\3\2\2\2\u0848\u07f5\3\2" + - "\2\2\u0848\u0818\3\2\2\2\u0848\u0830\3\2\2\2\u0849\u0177\3\2\2\2\u084a" + - "\u084b\7C\2\2\u084b\u084d\7!\2\2\u084c\u084e\5,\27\2\u084d\u084c\3\2\2" + - "\2\u084d\u084e\3\2\2\2\u084e\u0852\3\2\2\2\u084f\u0851\5\u00e8u\2\u0850" + - "\u084f\3\2\2\2\u0851\u0854\3\2\2\2\u0852\u0850\3\2\2\2\u0852\u0853\3\2" + - "\2\2\u0853\u0855\3\2\2\2\u0854\u0852\3\2\2\2\u0855\u0857\7h\2\2\u0856" + - "\u0858\5\u017c\u00bf\2\u0857\u0856\3\2\2\2\u0857\u0858\3\2\2\2\u0858\u0859" + - "\3\2\2\2\u0859\u085b\7;\2\2\u085a\u085c\5\u0190\u00c9\2\u085b\u085a\3" + - "\2\2\2\u085b\u085c\3\2\2\2\u085c\u085d\3\2\2\2\u085d\u085f\7<\2\2\u085e" + - "\u0860\5d\63\2\u085f\u085e\3\2\2\2\u085f\u0860\3\2\2\2\u0860\u0179\3\2" + - "\2\2\u0861\u0863\7!\2\2\u0862\u0864\5,\27\2\u0863\u0862\3\2\2\2\u0863" + - "\u0864\3\2\2\2\u0864\u0868\3\2\2\2\u0865\u0867\5\u00e8u\2\u0866\u0865" + - "\3\2\2\2\u0867\u086a\3\2\2\2\u0868\u0866\3\2\2\2\u0868\u0869\3\2\2\2\u0869" + - "\u086b\3\2\2\2\u086a\u0868\3\2\2\2\u086b\u0876\7h\2\2\u086c\u0870\7C\2" + - "\2\u086d\u086f\5\u00e8u\2\u086e\u086d\3\2\2\2\u086f\u0872\3\2\2\2\u0870" + - "\u086e\3\2\2\2\u0870\u0871\3\2\2\2\u0871\u0873\3\2\2\2\u0872\u0870\3\2" + - "\2\2\u0873\u0875\7h\2\2\u0874\u086c\3\2\2\2\u0875\u0878\3\2\2\2\u0876" + - "\u0874\3\2\2\2\u0876\u0877\3\2\2\2\u0877\u087a\3\2\2\2\u0878\u0876\3\2" + - "\2\2\u0879\u087b\5\u017c\u00bf\2\u087a\u0879\3\2\2\2\u087a\u087b\3\2\2" + - "\2\u087b\u087c\3\2\2\2\u087c\u087e\7;\2\2\u087d\u087f\5\u0190\u00c9\2" + - "\u087e\u087d\3\2\2\2\u087e\u087f\3\2\2\2\u087f\u0880\3\2\2\2\u0880\u0882" + - "\7<\2\2\u0881\u0883\5d\63\2\u0882\u0881\3\2\2\2\u0882\u0883\3\2\2\2\u0883" + - "\u089d\3\2\2\2\u0884\u0885\5<\37\2\u0885\u0886\7C\2\2\u0886\u0888\7!\2" + - "\2\u0887\u0889\5,\27\2\u0888\u0887\3\2\2\2\u0888\u0889\3\2\2\2\u0889\u088d" + - "\3\2\2\2\u088a\u088c\5\u00e8u\2\u088b\u088a\3\2\2\2\u088c\u088f\3\2\2" + - "\2\u088d\u088b\3\2\2\2\u088d\u088e\3\2\2\2\u088e\u0890\3\2\2\2\u088f\u088d" + - "\3\2\2\2\u0890\u0892\7h\2\2\u0891\u0893\5\u017c\u00bf\2\u0892\u0891\3" + - "\2\2\2\u0892\u0893\3\2\2\2\u0893\u0894\3\2\2\2\u0894\u0896\7;\2\2\u0895" + - "\u0897\5\u0190\u00c9\2\u0896\u0895\3\2\2\2\u0896\u0897\3\2\2\2\u0897\u0898" + - "\3\2\2\2\u0898\u089a\7<\2\2\u0899\u089b\5d\63\2\u089a\u0899\3\2\2\2\u089a" + - "\u089b\3\2\2\2\u089b\u089d\3\2\2\2\u089c\u0861\3\2\2\2\u089c\u0884\3\2" + - "\2\2\u089d\u017b\3\2\2\2\u089e\u08a2\5,\27\2\u089f\u08a0\7F\2\2\u08a0" + - "\u08a2\7E\2\2\u08a1\u089e\3\2\2\2\u08a1\u089f\3\2\2\2\u08a2\u017d\3\2" + - "\2\2\u08a3\u08a4\5\u0162\u00b2\2\u08a4\u08a5\7C\2\2\u08a5\u08a6\7h\2\2" + - "\u08a6\u08b1\3\2\2\2\u08a7\u08a8\7*\2\2\u08a8\u08a9\7C\2\2\u08a9\u08b1" + - "\7h\2\2\u08aa\u08ab\58\35\2\u08ab\u08ac\7C\2\2\u08ac\u08ad\7*\2\2\u08ad" + - "\u08ae\7C\2\2\u08ae\u08af\7h\2\2\u08af\u08b1\3\2\2\2\u08b0\u08a3\3\2\2" + - "\2\u08b0\u08a7\3\2\2\2\u08b0\u08aa\3\2\2\2\u08b1\u017f\3\2\2\2\u08b2\u08b3" + - "\7C\2\2\u08b3\u08b4\7h\2\2\u08b4\u0181\3\2\2\2\u08b5\u08b6\7*\2\2\u08b6" + - "\u08b7\7C\2\2\u08b7\u08bf\7h\2\2\u08b8\u08b9\58\35\2\u08b9\u08ba\7C\2" + - "\2\u08ba\u08bb\7*\2\2\u08bb\u08bc\7C\2\2\u08bc\u08bd\7h\2\2\u08bd\u08bf" + - "\3\2\2\2\u08be\u08b5\3\2\2\2\u08be\u08b8\3\2\2\2\u08bf\u0183\3\2\2\2\u08c0" + - "\u08c1\5<\37\2\u08c1\u08c2\7?\2\2\u08c2\u08c3\5\u01a0\u00d1\2\u08c3\u08c4" + - "\7@\2\2\u08c4\u08cb\3\2\2\2\u08c5\u08c6\5\u0168\u00b5\2\u08c6\u08c7\7" + - "?\2\2\u08c7\u08c8\5\u01a0\u00d1\2\u08c8\u08c9\7@\2\2\u08c9\u08cb\3\2\2" + - "\2\u08ca\u08c0\3\2\2\2\u08ca\u08c5\3\2\2\2\u08cb\u08d3\3\2\2\2\u08cc\u08cd" + - "\5\u0166\u00b4\2\u08cd\u08ce\7?\2\2\u08ce\u08cf\5\u01a0\u00d1\2\u08cf" + - "\u08d0\7@\2\2\u08d0\u08d2\3\2\2\2\u08d1\u08cc\3\2\2\2\u08d2\u08d5\3\2" + - "\2\2\u08d3\u08d1\3\2\2\2\u08d3\u08d4\3\2\2\2\u08d4\u0185\3\2\2\2\u08d5" + - "\u08d3\3\2\2\2\u08d6\u08d7\5\u016e\u00b8\2\u08d7\u08d8\7?\2\2\u08d8\u08d9" + - "\5\u01a0\u00d1\2\u08d9\u08da\7@\2\2\u08da\u08e2\3\2\2\2\u08db\u08dc\5" + - "\u016c\u00b7\2\u08dc\u08dd\7?\2\2\u08dd\u08de\5\u01a0\u00d1\2\u08de\u08df" + - "\7@\2\2\u08df\u08e1\3\2\2\2\u08e0\u08db\3\2\2\2\u08e1\u08e4\3\2\2\2\u08e2" + - "\u08e0\3\2\2\2\u08e2\u08e3\3\2\2\2\u08e3\u0187\3\2\2\2\u08e4\u08e2\3\2" + - "\2\2\u08e5\u08e6\5<\37\2\u08e6\u08e7\7?\2\2\u08e7\u08e8\5\u01a0\u00d1" + - "\2\u08e8\u08e9\7@\2\2\u08e9\u08f0\3\2\2\2\u08ea\u08eb\5\u0174\u00bb\2" + - "\u08eb\u08ec\7?\2\2\u08ec\u08ed\5\u01a0\u00d1\2\u08ed\u08ee\7@\2\2\u08ee" + - "\u08f0\3\2\2\2\u08ef\u08e5\3\2\2\2\u08ef\u08ea\3\2\2\2\u08f0\u08f8\3\2" + - "\2\2\u08f1\u08f2\5\u0172\u00ba\2\u08f2\u08f3\7?\2\2\u08f3\u08f4\5\u01a0" + - "\u00d1\2\u08f4\u08f5\7@\2\2\u08f5\u08f7\3\2\2\2\u08f6\u08f1\3\2\2\2\u08f7" + - "\u08fa\3\2\2\2\u08f8\u08f6\3\2\2\2\u08f8\u08f9\3\2\2\2\u08f9\u0189\3\2" + - "\2\2\u08fa\u08f8\3\2\2\2\u08fb\u08fc\5> \2\u08fc\u08fe\7;\2\2\u08fd\u08ff" + - "\5\u0190\u00c9\2\u08fe\u08fd\3\2\2\2\u08fe\u08ff\3\2\2\2\u08ff\u0900\3" + - "\2\2\2\u0900\u0901\7<\2\2\u0901\u0940\3\2\2\2\u0902\u0903\58\35\2\u0903" + - "\u0905\7C\2\2\u0904\u0906\5,\27\2\u0905\u0904\3\2\2\2\u0905\u0906\3\2" + - "\2\2\u0906\u0907\3\2\2\2\u0907\u0908\7h\2\2\u0908\u090a\7;\2\2\u0909\u090b" + - "\5\u0190\u00c9\2\u090a\u0909\3\2\2\2\u090a\u090b\3\2\2\2\u090b\u090c\3" + - "\2\2\2\u090c\u090d\7<\2\2\u090d\u0940\3\2\2\2\u090e\u090f\5<\37\2\u090f" + - "\u0911\7C\2\2\u0910\u0912\5,\27\2\u0911\u0910\3\2\2\2\u0911\u0912\3\2" + - "\2\2\u0912\u0913\3\2\2\2\u0913\u0914\7h\2\2\u0914\u0916\7;\2\2\u0915\u0917" + - "\5\u0190\u00c9\2\u0916\u0915\3\2\2\2\u0916\u0917\3\2\2\2\u0917\u0918\3" + - "\2\2\2\u0918\u0919\7<\2\2\u0919\u0940\3\2\2\2\u091a\u091b\5\u0162\u00b2" + - "\2\u091b\u091d\7C\2\2\u091c\u091e\5,\27\2\u091d\u091c\3\2\2\2\u091d\u091e" + - "\3\2\2\2\u091e\u091f\3\2\2\2\u091f\u0920\7h\2\2\u0920\u0922\7;\2\2\u0921" + - "\u0923\5\u0190\u00c9\2\u0922\u0921\3\2\2\2\u0922\u0923\3\2\2\2\u0923\u0924" + - "\3\2\2\2\u0924\u0925\7<\2\2\u0925\u0940\3\2\2\2\u0926\u0927\7*\2\2\u0927" + - "\u0929\7C\2\2\u0928\u092a\5,\27\2\u0929\u0928\3\2\2\2\u0929\u092a\3\2" + - "\2\2\u092a\u092b\3\2\2\2\u092b\u092c\7h\2\2\u092c\u092e\7;\2\2\u092d\u092f" + - "\5\u0190\u00c9\2\u092e\u092d\3\2\2\2\u092e\u092f\3\2\2\2\u092f\u0930\3" + - "\2\2\2\u0930\u0940\7<\2\2\u0931\u0932\58\35\2\u0932\u0933\7C\2\2\u0933" + - "\u0934\7*\2\2\u0934\u0936\7C\2\2\u0935\u0937\5,\27\2\u0936\u0935\3\2\2" + - "\2\u0936\u0937\3\2\2\2\u0937\u0938\3\2\2\2\u0938\u0939\7h\2\2\u0939\u093b" + - "\7;\2\2\u093a\u093c\5\u0190\u00c9\2\u093b\u093a\3\2\2\2\u093b\u093c\3" + - "\2\2\2\u093c\u093d\3\2\2\2\u093d\u093e\7<\2\2\u093e\u0940\3\2\2\2\u093f" + - "\u08fb\3\2\2\2\u093f\u0902\3\2\2\2\u093f\u090e\3\2\2\2\u093f\u091a\3\2" + - "\2\2\u093f\u0926\3\2\2\2\u093f\u0931\3\2\2\2\u0940\u018b\3\2\2\2\u0941" + - "\u0943\7C\2\2\u0942\u0944\5,\27\2\u0943\u0942\3\2\2\2\u0943\u0944\3\2" + - "\2\2\u0944\u0945\3\2\2\2\u0945\u0946\7h\2\2\u0946\u0948\7;\2\2\u0947\u0949" + - "\5\u0190\u00c9\2\u0948\u0947\3\2\2\2\u0948\u0949\3\2\2\2"; - private static final String _serializedATNSegment1 = - "\u0949\u094a\3\2\2\2\u094a\u094b\7<\2\2\u094b\u018d\3\2\2\2\u094c\u094d" + - "\5> \2\u094d\u094f\7;\2\2\u094e\u0950\5\u0190\u00c9\2\u094f\u094e\3\2" + - "\2\2\u094f\u0950\3\2\2\2\u0950\u0951\3\2\2\2\u0951\u0952\7<\2\2\u0952" + - "\u0985\3\2\2\2\u0953\u0954\58\35\2\u0954\u0956\7C\2\2\u0955\u0957\5,\27" + - "\2\u0956\u0955\3\2\2\2\u0956\u0957\3\2\2\2\u0957\u0958\3\2\2\2\u0958\u0959" + - "\7h\2\2\u0959\u095b\7;\2\2\u095a\u095c\5\u0190\u00c9\2\u095b\u095a\3\2" + - "\2\2\u095b\u095c\3\2\2\2\u095c\u095d\3\2\2\2\u095d\u095e\7<\2\2\u095e" + - "\u0985\3\2\2\2\u095f\u0960\5<\37\2\u0960\u0962\7C\2\2\u0961\u0963\5,\27" + - "\2\u0962\u0961\3\2\2\2\u0962\u0963\3\2\2\2\u0963\u0964\3\2\2\2\u0964\u0965" + - "\7h\2\2\u0965\u0967\7;\2\2\u0966\u0968\5\u0190\u00c9\2\u0967\u0966\3\2" + - "\2\2\u0967\u0968\3\2\2\2\u0968\u0969\3\2\2\2\u0969\u096a\7<\2\2\u096a" + - "\u0985\3\2\2\2\u096b\u096c\7*\2\2\u096c\u096e\7C\2\2\u096d\u096f\5,\27" + - "\2\u096e\u096d\3\2\2\2\u096e\u096f\3\2\2\2\u096f\u0970\3\2\2\2\u0970\u0971" + - "\7h\2\2\u0971\u0973\7;\2\2\u0972\u0974\5\u0190\u00c9\2\u0973\u0972\3\2" + - "\2\2\u0973\u0974\3\2\2\2\u0974\u0975\3\2\2\2\u0975\u0985\7<\2\2\u0976" + - "\u0977\58\35\2\u0977\u0978\7C\2\2\u0978\u0979\7*\2\2\u0979\u097b\7C\2" + - "\2\u097a\u097c\5,\27\2\u097b\u097a\3\2\2\2\u097b\u097c\3\2\2\2\u097c\u097d" + - "\3\2\2\2\u097d\u097e\7h\2\2\u097e\u0980\7;\2\2\u097f\u0981\5\u0190\u00c9" + - "\2\u0980\u097f\3\2\2\2\u0980\u0981\3\2\2\2\u0981\u0982\3\2\2\2\u0982\u0983" + - "\7<\2\2\u0983\u0985\3\2\2\2\u0984\u094c\3\2\2\2\u0984\u0953\3\2\2\2\u0984" + - "\u095f\3\2\2\2\u0984\u096b\3\2\2\2\u0984\u0976\3\2\2\2\u0985\u018f\3\2" + - "\2\2\u0986\u098b\5\u01a0\u00d1\2\u0987\u0988\7B\2\2\u0988\u098a\5\u01a0" + - "\u00d1\2\u0989\u0987\3\2\2\2\u098a\u098d\3\2\2\2\u098b\u0989\3\2\2\2\u098b" + - "\u098c\3\2\2\2\u098c\u0191\3\2\2\2\u098d\u098b\3\2\2\2\u098e\u098f\5<" + - "\37\2\u098f\u0991\7\\\2\2\u0990\u0992\5,\27\2\u0991\u0990\3\2\2\2\u0991" + - "\u0992\3\2\2\2\u0992\u0993\3\2\2\2\u0993\u0994\7h\2\2\u0994\u09be\3\2" + - "\2\2\u0995\u0996\5\16\b\2\u0996\u0998\7\\\2\2\u0997\u0999\5,\27\2\u0998" + - "\u0997\3\2\2\2\u0998\u0999\3\2\2\2\u0999\u099a\3\2\2\2\u099a\u099b\7h" + - "\2\2\u099b\u09be\3\2\2\2\u099c\u099d\5\u0162\u00b2\2\u099d\u099f\7\\\2" + - "\2\u099e\u09a0\5,\27\2\u099f\u099e\3\2\2\2\u099f\u09a0\3\2\2\2\u09a0\u09a1" + - "\3\2\2\2\u09a1\u09a2\7h\2\2\u09a2\u09be\3\2\2\2\u09a3\u09a4\7*\2\2\u09a4" + - "\u09a6\7\\\2\2\u09a5\u09a7\5,\27\2\u09a6\u09a5\3\2\2\2\u09a6\u09a7\3\2" + - "\2\2\u09a7\u09a8\3\2\2\2\u09a8\u09be\7h\2\2\u09a9\u09aa\58\35\2\u09aa" + - "\u09ab\7C\2\2\u09ab\u09ac\7*\2\2\u09ac\u09ae\7\\\2\2\u09ad\u09af\5,\27" + - "\2\u09ae\u09ad\3\2\2\2\u09ae\u09af\3\2\2\2\u09af\u09b0\3\2\2\2\u09b0\u09b1" + - "\7h\2\2\u09b1\u09be\3\2\2\2\u09b2\u09b3\5\22\n\2\u09b3\u09b5\7\\\2\2\u09b4" + - "\u09b6\5,\27\2\u09b5\u09b4\3\2\2\2\u09b5\u09b6\3\2\2\2\u09b6\u09b7\3\2" + - "\2\2\u09b7\u09b8\7!\2\2\u09b8\u09be\3\2\2\2\u09b9\u09ba\5 \21\2\u09ba" + - "\u09bb\7\\\2\2\u09bb\u09bc\7!\2\2\u09bc\u09be\3\2\2\2\u09bd\u098e\3\2" + - "\2\2\u09bd\u0995\3\2\2\2\u09bd\u099c\3\2\2\2\u09bd\u09a3\3\2\2\2\u09bd" + - "\u09a9\3\2\2\2\u09bd\u09b2\3\2\2\2\u09bd\u09b9\3\2\2\2\u09be\u0193\3\2" + - "\2\2\u09bf\u09c1\7\\\2\2\u09c0\u09c2\5,\27\2\u09c1\u09c0\3\2\2\2\u09c1" + - "\u09c2\3\2\2\2\u09c2\u09c3\3\2\2\2\u09c3\u09c4\7h\2\2\u09c4\u0195\3\2" + - "\2\2\u09c5\u09c6\5<\37\2\u09c6\u09c8\7\\\2\2\u09c7\u09c9\5,\27\2\u09c8" + - "\u09c7\3\2\2\2\u09c8\u09c9\3\2\2\2\u09c9\u09ca\3\2\2\2\u09ca\u09cb\7h" + - "\2\2\u09cb\u09ee\3\2\2\2\u09cc\u09cd\5\16\b\2\u09cd\u09cf\7\\\2\2\u09ce" + - "\u09d0\5,\27\2\u09cf\u09ce\3\2\2\2\u09cf\u09d0\3\2\2\2\u09d0\u09d1\3\2" + - "\2\2\u09d1\u09d2\7h\2\2\u09d2\u09ee\3\2\2\2\u09d3\u09d4\7*\2\2\u09d4\u09d6" + - "\7\\\2\2\u09d5\u09d7\5,\27\2\u09d6\u09d5\3\2\2\2\u09d6\u09d7\3\2\2\2\u09d7" + - "\u09d8\3\2\2\2\u09d8\u09ee\7h\2\2\u09d9\u09da\58\35\2\u09da\u09db\7C\2" + - "\2\u09db\u09dc\7*\2\2\u09dc\u09de\7\\\2\2\u09dd\u09df\5,\27\2\u09de\u09dd" + - "\3\2\2\2\u09de\u09df\3\2\2\2\u09df\u09e0\3\2\2\2\u09e0\u09e1\7h\2\2\u09e1" + - "\u09ee\3\2\2\2\u09e2\u09e3\5\22\n\2\u09e3\u09e5\7\\\2\2\u09e4\u09e6\5" + - ",\27\2\u09e5\u09e4\3\2\2\2\u09e5\u09e6\3\2\2\2\u09e6\u09e7\3\2\2\2\u09e7" + - "\u09e8\7!\2\2\u09e8\u09ee\3\2\2\2\u09e9\u09ea\5 \21\2\u09ea\u09eb\7\\" + - "\2\2\u09eb\u09ec\7!\2\2\u09ec\u09ee\3\2\2\2\u09ed\u09c5\3\2\2\2\u09ed" + - "\u09cc\3\2\2\2\u09ed\u09d3\3\2\2\2\u09ed\u09d9\3\2\2\2\u09ed\u09e2\3\2" + - "\2\2\u09ed\u09e9\3\2\2\2\u09ee\u0197\3\2\2\2\u09ef\u09f0\7!\2\2\u09f0" + - "\u09f1\5\6\4\2\u09f1\u09f3\5\u019a\u00ce\2\u09f2\u09f4\5\"\22\2\u09f3" + - "\u09f2\3\2\2\2\u09f3\u09f4\3\2\2\2\u09f4\u0a06\3\2\2\2\u09f5\u09f6\7!" + - "\2\2\u09f6\u09f7\5\20\t\2\u09f7\u09f9\5\u019a\u00ce\2\u09f8\u09fa\5\"" + - "\22\2\u09f9\u09f8\3\2\2\2\u09f9\u09fa\3\2\2\2\u09fa\u0a06\3\2\2\2\u09fb" + - "\u09fc\7!\2\2\u09fc\u09fd\5\6\4\2\u09fd\u09fe\5\"\22\2\u09fe\u09ff\5\u00fa" + - "~\2\u09ff\u0a06\3\2\2\2\u0a00\u0a01\7!\2\2\u0a01\u0a02\5\20\t\2\u0a02" + - "\u0a03\5\"\22\2\u0a03\u0a04\5\u00fa~\2\u0a04\u0a06\3\2\2\2\u0a05\u09ef" + - "\3\2\2\2\u0a05\u09f5\3\2\2\2\u0a05\u09fb\3\2\2\2\u0a05\u0a00\3\2\2\2\u0a06" + - "\u0199\3\2\2\2\u0a07\u0a0b\5\u019c\u00cf\2\u0a08\u0a0a\5\u019c\u00cf\2" + - "\u0a09\u0a08\3\2\2\2\u0a0a\u0a0d\3\2\2\2\u0a0b\u0a09\3\2\2\2\u0a0b\u0a0c" + - "\3\2\2\2\u0a0c\u019b\3\2\2\2\u0a0d\u0a0b\3\2\2\2\u0a0e\u0a10\5\u00e8u" + - "\2\u0a0f\u0a0e\3\2\2\2\u0a10\u0a13\3\2\2\2\u0a11\u0a0f\3\2\2\2\u0a11\u0a12" + - "\3\2\2\2\u0a12\u0a14\3\2\2\2\u0a13\u0a11\3\2\2\2\u0a14\u0a15\7?\2\2\u0a15" + - "\u0a16\5\u01a0\u00d1\2\u0a16\u0a17\7@\2\2\u0a17\u019d\3\2\2\2\u0a18\u0a19" + - "\5\u01a0\u00d1\2\u0a19\u019f\3\2\2\2\u0a1a\u0a1d\5\u01a2\u00d2\2\u0a1b" + - "\u0a1d\5\u01aa\u00d6\2\u0a1c\u0a1a\3\2\2\2\u0a1c\u0a1b\3\2\2\2\u0a1d\u01a1" + - "\3\2\2\2\u0a1e\u0a1f\5\u01a4\u00d3\2\u0a1f\u0a20\7[\2\2\u0a20\u0a21\5" + - "\u01a8\u00d5\2\u0a21\u01a3\3\2\2\2\u0a22\u0a2d\7h\2\2\u0a23\u0a25\7;\2" + - "\2\u0a24\u0a26\5\u0098M\2\u0a25\u0a24\3\2\2\2\u0a25\u0a26\3\2\2\2\u0a26" + - "\u0a27\3\2\2\2\u0a27\u0a2d\7<\2\2\u0a28\u0a29\7;\2\2\u0a29\u0a2a\5\u01a6" + - "\u00d4\2\u0a2a\u0a2b\7<\2\2\u0a2b\u0a2d\3\2\2\2\u0a2c\u0a22\3\2\2\2\u0a2c" + - "\u0a23\3\2\2\2\u0a2c\u0a28\3\2\2\2\u0a2d\u01a5\3\2\2\2\u0a2e\u0a33\7h" + - "\2\2\u0a2f\u0a30\7B\2\2\u0a30\u0a32\7h\2\2\u0a31\u0a2f\3\2\2\2\u0a32\u0a35" + - "\3\2\2\2\u0a33\u0a31\3\2\2\2\u0a33\u0a34\3\2\2\2\u0a34\u01a7\3\2\2\2\u0a35" + - "\u0a33\3\2\2\2\u0a36\u0a39\5\u01a0\u00d1\2\u0a37\u0a39\5\u00fe\u0080\2" + - "\u0a38\u0a36\3\2\2\2\u0a38\u0a37\3\2\2\2\u0a39\u01a9\3\2\2\2\u0a3a\u0a3d" + - "\5\u01b2\u00da\2\u0a3b\u0a3d\5\u01ac\u00d7\2\u0a3c\u0a3a\3\2\2\2\u0a3c" + - "\u0a3b\3\2\2\2\u0a3d\u01ab\3\2\2\2\u0a3e\u0a3f\5\u01ae\u00d8\2\u0a3f\u0a40" + - "\5\u01b0\u00d9\2\u0a40\u0a41\5\u01a0\u00d1\2\u0a41\u01ad\3\2\2\2\u0a42" + - "\u0a46\5<\37\2\u0a43\u0a46\5\u017e\u00c0\2\u0a44\u0a46\5\u0184\u00c3\2" + - "\u0a45\u0a42\3\2\2\2\u0a45\u0a43\3\2\2\2\u0a45\u0a44\3\2\2\2\u0a46\u01af" + - "\3\2\2\2\u0a47\u0a48\t\5\2\2\u0a48\u01b1\3\2\2\2\u0a49\u0a51\5\u01b4\u00db" + - "\2\u0a4a\u0a4b\5\u01b4\u00db\2\u0a4b\u0a4c\7I\2\2\u0a4c\u0a4d\5\u01a0" + - "\u00d1\2\u0a4d\u0a4e\7J\2\2\u0a4e\u0a4f\5\u01b2\u00da\2\u0a4f\u0a51\3" + - "\2\2\2\u0a50\u0a49\3\2\2\2\u0a50\u0a4a\3\2\2\2\u0a51\u01b3\3\2\2\2\u0a52" + - "\u0a53\b\u00db\1\2\u0a53\u0a54\5\u01b6\u00dc\2\u0a54\u0a5a\3\2\2\2\u0a55" + - "\u0a56\f\3\2\2\u0a56\u0a57\7P\2\2\u0a57\u0a59\5\u01b6\u00dc\2\u0a58\u0a55" + - "\3\2\2\2\u0a59\u0a5c\3\2\2\2\u0a5a\u0a58\3\2\2\2\u0a5a\u0a5b\3\2\2\2\u0a5b" + - "\u01b5\3\2\2\2\u0a5c\u0a5a\3\2\2\2\u0a5d\u0a5e\b\u00dc\1\2\u0a5e\u0a5f" + - "\5\u01b8\u00dd\2\u0a5f\u0a65\3\2\2\2\u0a60\u0a61\f\3\2\2\u0a61\u0a62\7" + - "O\2\2\u0a62\u0a64\5\u01b8\u00dd\2\u0a63\u0a60\3\2\2\2\u0a64\u0a67\3\2" + - "\2\2\u0a65\u0a63\3\2\2\2\u0a65\u0a66\3\2\2\2\u0a66\u01b7\3\2\2\2\u0a67" + - "\u0a65\3\2\2\2\u0a68\u0a69\b\u00dd\1\2\u0a69\u0a6a\5\u01ba\u00de\2\u0a6a" + - "\u0a70\3\2\2\2\u0a6b\u0a6c\f\3\2\2\u0a6c\u0a6d\7X\2\2\u0a6d\u0a6f\5\u01ba" + - "\u00de\2\u0a6e\u0a6b\3\2\2\2\u0a6f\u0a72\3\2\2\2\u0a70\u0a6e\3\2\2\2\u0a70" + - "\u0a71\3\2\2\2\u0a71\u01b9\3\2\2\2\u0a72\u0a70\3\2\2\2\u0a73\u0a74\b\u00de" + - "\1\2\u0a74\u0a75\5\u01bc\u00df\2\u0a75\u0a7b\3\2\2\2\u0a76\u0a77\f\3\2" + - "\2\u0a77\u0a78\7Y\2\2\u0a78\u0a7a\5\u01bc\u00df\2\u0a79\u0a76\3\2\2\2" + - "\u0a7a\u0a7d\3\2\2\2\u0a7b\u0a79\3\2\2\2\u0a7b\u0a7c\3\2\2\2\u0a7c\u01bb" + - "\3\2\2\2\u0a7d\u0a7b\3\2\2\2\u0a7e\u0a7f\b\u00df\1\2\u0a7f\u0a80\5\u01be" + - "\u00e0\2\u0a80\u0a86\3\2\2\2\u0a81\u0a82\f\3\2\2\u0a82\u0a83\7W\2\2\u0a83" + - "\u0a85\5\u01be\u00e0\2\u0a84\u0a81\3\2\2\2\u0a85\u0a88\3\2\2\2\u0a86\u0a84" + - "\3\2\2\2\u0a86\u0a87\3\2\2\2\u0a87\u01bd\3\2\2\2\u0a88\u0a86\3\2\2\2\u0a89" + - "\u0a8a\b\u00e0\1\2\u0a8a\u0a8b\5\u01c0\u00e1\2\u0a8b\u0a94\3\2\2\2\u0a8c" + - "\u0a8d\f\4\2\2\u0a8d\u0a8e\7K\2\2\u0a8e\u0a93\5\u01c0\u00e1\2\u0a8f\u0a90" + - "\f\3\2\2\u0a90\u0a91\7N\2\2\u0a91\u0a93\5\u01c0\u00e1\2\u0a92\u0a8c\3" + - "\2\2\2\u0a92\u0a8f\3\2\2\2\u0a93\u0a96\3\2\2\2\u0a94\u0a92\3\2\2\2\u0a94" + - "\u0a95\3\2\2\2\u0a95\u01bf\3\2\2\2\u0a96\u0a94\3\2\2\2\u0a97\u0a98\b\u00e1" + - "\1\2\u0a98\u0a99\5\u01c2\u00e2\2\u0a99\u0aab\3\2\2\2\u0a9a\u0a9b\f\7\2" + - "\2\u0a9b\u0a9c\7F\2\2\u0a9c\u0aaa\5\u01c2\u00e2\2\u0a9d\u0a9e\f\6\2\2" + - "\u0a9e\u0a9f\7E\2\2\u0a9f\u0aaa\5\u01c2\u00e2\2\u0aa0\u0aa1\f\5\2\2\u0aa1" + - "\u0aa2\7L\2\2\u0aa2\u0aaa\5\u01c2\u00e2\2\u0aa3\u0aa4\f\4\2\2\u0aa4\u0aa5" + - "\7M\2\2\u0aa5\u0aaa\5\u01c2\u00e2\2\u0aa6\u0aa7\f\3\2\2\u0aa7\u0aa8\7" + - "\34\2\2\u0aa8\u0aaa\5\16\b\2\u0aa9\u0a9a\3\2\2\2\u0aa9\u0a9d\3\2\2\2\u0aa9" + - "\u0aa0\3\2\2\2\u0aa9\u0aa3\3\2\2\2\u0aa9\u0aa6\3\2\2\2\u0aaa\u0aad\3\2" + - "\2\2\u0aab\u0aa9\3\2\2\2\u0aab\u0aac\3\2\2\2\u0aac\u01c1\3\2\2\2\u0aad" + - "\u0aab\3\2\2\2\u0aae\u0aaf\b\u00e2\1\2\u0aaf\u0ab0\5\u01c4\u00e3\2\u0ab0" + - "\u0ac0\3\2\2\2\u0ab1\u0ab2\f\5\2\2\u0ab2\u0ab3\7F\2\2\u0ab3\u0ab4\7F\2" + - "\2\u0ab4\u0abf\5\u01c4\u00e3\2\u0ab5\u0ab6\f\4\2\2\u0ab6\u0ab7\7E\2\2" + - "\u0ab7\u0ab8\7E\2\2\u0ab8\u0abf\5\u01c4\u00e3\2\u0ab9\u0aba\f\3\2\2\u0aba" + - "\u0abb\7E\2\2\u0abb\u0abc\7E\2\2\u0abc\u0abd\7E\2\2\u0abd\u0abf\5\u01c4" + - "\u00e3\2\u0abe\u0ab1\3\2\2\2\u0abe\u0ab5\3\2\2\2\u0abe\u0ab9\3\2\2\2\u0abf" + - "\u0ac2\3\2\2\2\u0ac0\u0abe\3\2\2\2\u0ac0\u0ac1\3\2\2\2\u0ac1\u01c3\3\2" + - "\2\2\u0ac2\u0ac0\3\2\2\2\u0ac3\u0ac4\b\u00e3\1\2\u0ac4\u0ac5\5\u01c6\u00e4" + - "\2\u0ac5\u0ace\3\2\2\2\u0ac6\u0ac7\f\4\2\2\u0ac7\u0ac8\7S\2\2\u0ac8\u0acd" + - "\5\u01c6\u00e4\2\u0ac9\u0aca\f\3\2\2\u0aca\u0acb\7T\2\2\u0acb\u0acd\5" + - "\u01c6\u00e4\2\u0acc\u0ac6\3\2\2\2\u0acc\u0ac9\3\2\2\2\u0acd\u0ad0\3\2" + - "\2\2\u0ace\u0acc\3\2\2\2\u0ace\u0acf\3\2\2\2\u0acf\u01c5\3\2\2\2\u0ad0" + - "\u0ace\3\2\2\2\u0ad1\u0ad2\b\u00e4\1\2\u0ad2\u0ad3\5\u01c8\u00e5\2\u0ad3" + - "\u0adf\3\2\2\2\u0ad4\u0ad5\f\5\2\2\u0ad5\u0ad6\7U\2\2\u0ad6\u0ade\5\u01c8" + - "\u00e5\2\u0ad7\u0ad8\f\4\2\2\u0ad8\u0ad9\7V\2\2\u0ad9\u0ade\5\u01c8\u00e5" + - "\2\u0ada\u0adb\f\3\2\2\u0adb\u0adc\7Z\2\2\u0adc\u0ade\5\u01c8\u00e5\2" + - "\u0add\u0ad4\3\2\2\2\u0add\u0ad7\3\2\2\2\u0add\u0ada\3\2\2\2\u0ade\u0ae1" + - "\3\2\2\2\u0adf\u0add\3\2\2\2\u0adf\u0ae0\3\2\2\2\u0ae0\u01c7\3\2\2\2\u0ae1" + - "\u0adf\3\2\2\2\u0ae2\u0aea\5\u01ca\u00e6\2\u0ae3\u0aea\5\u01cc\u00e7\2" + - "\u0ae4\u0ae5\7S\2\2\u0ae5\u0aea\5\u01c8\u00e5\2\u0ae6\u0ae7\7T\2\2\u0ae7" + - "\u0aea\5\u01c8\u00e5\2\u0ae8\u0aea\5\u01ce\u00e8\2\u0ae9\u0ae2\3\2\2\2" + - "\u0ae9\u0ae3\3\2\2\2\u0ae9\u0ae4\3\2\2\2\u0ae9\u0ae6\3\2\2\2\u0ae9\u0ae8" + - "\3\2\2\2\u0aea\u01c9\3\2\2\2\u0aeb\u0aec\7Q\2\2\u0aec\u0aed\5\u01c8\u00e5" + - "\2\u0aed\u01cb\3\2\2\2\u0aee\u0aef\7R\2\2\u0aef\u0af0\5\u01c8\u00e5\2" + - "\u0af0\u01cd\3\2\2\2\u0af1\u0af8\5\u01d0\u00e9\2\u0af2\u0af3\7H\2\2\u0af3" + - "\u0af8\5\u01c8\u00e5\2\u0af4\u0af5\7G\2\2\u0af5\u0af8\5\u01c8\u00e5\2" + - "\u0af6\u0af8\5\u01da\u00ee\2\u0af7\u0af1\3\2\2\2\u0af7\u0af2\3\2\2\2\u0af7" + - "\u0af4\3\2\2\2\u0af7\u0af6\3\2\2\2\u0af8\u01cf\3\2\2\2\u0af9\u0afc\5\u0162" + - "\u00b2\2\u0afa\u0afc\5<\37\2\u0afb\u0af9\3\2\2\2\u0afb\u0afa\3\2\2\2\u0afc" + - "\u0b01\3\2\2\2\u0afd\u0b00\5\u01d4\u00eb\2\u0afe\u0b00\5\u01d8\u00ed\2" + - "\u0aff\u0afd\3\2\2\2\u0aff\u0afe\3\2\2\2\u0b00\u0b03\3\2\2\2\u0b01\u0aff" + - "\3\2\2\2\u0b01\u0b02\3\2\2\2\u0b02\u01d1\3\2\2\2\u0b03\u0b01\3\2\2\2\u0b04" + - "\u0b05\5\u01d0\u00e9\2\u0b05\u0b06\7Q\2\2\u0b06\u01d3\3\2\2\2\u0b07\u0b08" + - "\7Q\2\2\u0b08\u01d5\3\2\2\2\u0b09\u0b0a\5\u01d0\u00e9\2\u0b0a\u0b0b\7" + - "R\2\2\u0b0b\u01d7\3\2\2\2\u0b0c\u0b0d\7R\2\2\u0b0d\u01d9\3\2\2\2\u0b0e" + - "\u0b0f\7;\2\2\u0b0f\u0b10\5\6\4\2\u0b10\u0b11\7<\2\2\u0b11\u0b12\5\u01c8" + - "\u00e5\2\u0b12\u0b2a\3\2\2\2\u0b13\u0b14\7;\2\2\u0b14\u0b18\5\16\b\2\u0b15" + - "\u0b17\5*\26\2\u0b16\u0b15\3\2\2\2\u0b17\u0b1a\3\2\2\2\u0b18\u0b16\3\2" + - "\2\2\u0b18\u0b19\3\2\2\2\u0b19\u0b1b\3\2\2\2\u0b1a\u0b18\3\2\2\2\u0b1b" + - "\u0b1c\7<\2\2\u0b1c\u0b1d\5\u01ce\u00e8\2\u0b1d\u0b2a\3\2\2\2\u0b1e\u0b1f" + - "\7;\2\2\u0b1f\u0b23\5\16\b\2\u0b20\u0b22\5*\26\2\u0b21\u0b20\3\2\2\2\u0b22" + - "\u0b25\3\2\2\2\u0b23\u0b21\3\2\2\2\u0b23\u0b24\3\2\2\2\u0b24\u0b26\3\2" + - "\2\2\u0b25\u0b23\3\2\2\2\u0b26\u0b27\7<\2\2\u0b27\u0b28\5\u01a2\u00d2" + - "\2\u0b28\u0b2a\3\2\2\2\u0b29\u0b0e\3\2\2\2\u0b29\u0b13\3\2\2\2\u0b29\u0b1e" + - "\3\2\2\2\u0b2a\u01db\3\2\2\2\u0146\u01e0\u01e5\u01ec\u01f0\u01f4\u01fd" + - "\u0201\u0205\u0207\u020d\u0212\u0219\u021e\u0220\u0226\u022b\u0230\u0235" + - "\u0240\u024e\u0253\u025b\u0262\u0268\u026d\u0278\u027b\u0289\u028e\u0293" + - "\u0298\u029e\u02a8\u02b0\u02ba\u02c2\u02ce\u02d2\u02d7\u02dd\u02e5\u02ee" + - "\u02f9\u0316\u031a\u031f\u0325\u0328\u032b\u0337\u0342\u0350\u0357\u0360" + - "\u0367\u036c\u037b\u0382\u0388\u038c\u0390\u0394\u0398\u039d\u03a1\u03a5" + - "\u03a7\u03ac\u03b3\u03b8\u03ba\u03c0\u03c5\u03c9\u03dc\u03e1\u03f1\u03f6" + - "\u03fc\u0402\u0404\u0408\u040d\u0411\u0418\u041f\u0427\u042a\u042f\u0437" + - "\u043c\u0443\u044a\u044f\u0455\u0461\u0466\u046a\u0474\u0479\u0481\u0484" + - "\u0489\u0491\u0494\u0499\u049e\u04a3\u04a8\u04af\u04b4\u04bc\u04c1\u04c6" + - "\u04cb\u04d1\u04d7\u04da\u04dd\u04e6\u04ec\u04f2\u04f5\u04f8\u0500\u0505" + - "\u050a\u0510\u0513\u051e\u0527\u0531\u0536\u0541\u0546\u0552\u0557\u0563" + - "\u056d\u0572\u057a\u057d\u0584\u058c\u0592\u059b\u05a5\u05a9\u05ac\u05b5" + - "\u05c3\u05c6\u05cf\u05d4\u05dc\u05e2\u05ea\u05f6\u05fd\u060b\u0621\u0643" + - "\u064f\u0655\u0661\u066e\u0688\u068c\u0691\u0695\u0699\u06a1\u06a5\u06a9" + - "\u06b0\u06b9\u06c1\u06d0\u06dc\u06e2\u06e8\u06fd\u0702\u0708\u0714\u071f" + - "\u0729\u072c\u0731\u073a\u0740\u074a\u074f\u0758\u076f\u0779\u078f\u0796" + - "\u079e\u07a6\u07b1\u07c8\u07d2\u07dd\u07f3\u07f7\u07fc\u0804\u080a\u080e" + - "\u0812\u0816\u081c\u0821\u0826\u082a\u082e\u0834\u0839\u083e\u0842\u0846" + - "\u0848\u084d\u0852\u0857\u085b\u085f\u0863\u0868\u0870\u0876\u087a\u087e" + - "\u0882\u0888\u088d\u0892\u0896\u089a\u089c\u08a1\u08b0\u08be\u08ca\u08d3" + - "\u08e2\u08ef\u08f8\u08fe\u0905\u090a\u0911\u0916\u091d\u0922\u0929\u092e" + - "\u0936\u093b\u093f\u0943\u0948\u094f\u0956\u095b\u0962\u0967\u096e\u0973" + - "\u097b\u0980\u0984\u098b\u0991\u0998\u099f\u09a6\u09ae\u09b5\u09bd\u09c1" + - "\u09c8\u09cf\u09d6\u09de\u09e5\u09ed\u09f3\u09f9\u0a05\u0a0b\u0a11\u0a1c" + - "\u0a25\u0a2c\u0a33\u0a38\u0a3c\u0a45\u0a50\u0a5a\u0a65\u0a70\u0a7b\u0a86" + - "\u0a92\u0a94\u0aa9\u0aab\u0abe\u0ac0\u0acc\u0ace\u0add\u0adf\u0ae9\u0af7" + - "\u0afb\u0aff\u0b01\u0b18\u0b23\u0b29"; - public static final String _serializedATN = Utils.join( - new String[]{ - _serializedATNSegment0, - _serializedATNSegment1 - }, - "" - ); - public static final ATN _ATN = - new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - - static { - } -} diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Visitor.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Visitor.java deleted file mode 100644 index d353b25..0000000 --- a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Visitor.java +++ /dev/null @@ -1,1932 +0,0 @@ -// Generated from Java8.g4 by ANTLR 4.5 -package org.nuiton.config.plugin.parser.java; - -/* - * #%L - * Nuiton Config :: Maven plugin - * %% - * Copyright (C) 2016 Code Lutin, Tony Chemit - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ - -import org.antlr.v4.runtime.misc.NotNull; -import org.antlr.v4.runtime.tree.ParseTreeVisitor; - -/** - * This interface defines a complete generic visitor for a parse tree produced - * by {@link Java8Parser}. - * - * @param <Result> The return type of the visit operation. Use {@link Void} for - * operations with no return type. - */ -public interface Java8Visitor<Result> extends ParseTreeVisitor<Result> { - /** - * Visit a parse tree produced by {@link Java8Parser#literal}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitLiteral(@NotNull Java8Parser.LiteralContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#type}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitType(@NotNull Java8Parser.TypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#primitiveType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPrimitiveType(@NotNull Java8Parser.PrimitiveTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#numericType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitNumericType(@NotNull Java8Parser.NumericTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#integralType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitIntegralType(@NotNull Java8Parser.IntegralTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#floatingPointType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitFloatingPointType(@NotNull Java8Parser.FloatingPointTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#referenceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitReferenceType(@NotNull Java8Parser.ReferenceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classOrInterfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassOrInterfaceType(@NotNull Java8Parser.ClassOrInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassType(@NotNull Java8Parser.ClassTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classType_lf_classOrInterfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassType_lf_classOrInterfaceType(@NotNull Java8Parser.ClassType_lf_classOrInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classType_lfno_classOrInterfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassType_lfno_classOrInterfaceType(@NotNull Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#interfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInterfaceType(@NotNull Java8Parser.InterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#interfaceType_lf_classOrInterfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInterfaceType_lf_classOrInterfaceType(@NotNull Java8Parser.InterfaceType_lf_classOrInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#interfaceType_lfno_classOrInterfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInterfaceType_lfno_classOrInterfaceType(@NotNull Java8Parser.InterfaceType_lfno_classOrInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeVariable}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeVariable(@NotNull Java8Parser.TypeVariableContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#arrayType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitArrayType(@NotNull Java8Parser.ArrayTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#dims}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitDims(@NotNull Java8Parser.DimsContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeParameter}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeParameter(@NotNull Java8Parser.TypeParameterContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeParameterModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeParameterModifier(@NotNull Java8Parser.TypeParameterModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeBound}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeBound(@NotNull Java8Parser.TypeBoundContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#additionalBound}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAdditionalBound(@NotNull Java8Parser.AdditionalBoundContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeArguments}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeArguments(@NotNull Java8Parser.TypeArgumentsContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeArgumentList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeArgumentList(@NotNull Java8Parser.TypeArgumentListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeArgument}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeArgument(@NotNull Java8Parser.TypeArgumentContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#wildcard}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitWildcard(@NotNull Java8Parser.WildcardContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#wildcardBounds}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitWildcardBounds(@NotNull Java8Parser.WildcardBoundsContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#packageName}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPackageName(@NotNull Java8Parser.PackageNameContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeName}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeName(@NotNull Java8Parser.TypeNameContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#packageOrTypeName}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPackageOrTypeName(@NotNull Java8Parser.PackageOrTypeNameContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#expressionName}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitExpressionName(@NotNull Java8Parser.ExpressionNameContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodName}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodName(@NotNull Java8Parser.MethodNameContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#ambiguousName}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAmbiguousName(@NotNull Java8Parser.AmbiguousNameContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#compilationUnit}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitCompilationUnit(@NotNull Java8Parser.CompilationUnitContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#packageDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPackageDeclaration(@NotNull Java8Parser.PackageDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#packageModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPackageModifier(@NotNull Java8Parser.PackageModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#importDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitImportDeclaration(@NotNull Java8Parser.ImportDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#singleTypeImportDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSingleTypeImportDeclaration(@NotNull Java8Parser.SingleTypeImportDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeImportOnDemandDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeImportOnDemandDeclaration(@NotNull Java8Parser.TypeImportOnDemandDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#singleStaticImportDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSingleStaticImportDeclaration(@NotNull Java8Parser.SingleStaticImportDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#staticImportOnDemandDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitStaticImportOnDemandDeclaration(@NotNull Java8Parser.StaticImportOnDemandDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeDeclaration(@NotNull Java8Parser.TypeDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassDeclaration(@NotNull Java8Parser.ClassDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#normalClassDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitNormalClassDeclaration(@NotNull Java8Parser.NormalClassDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassModifier(@NotNull Java8Parser.ClassModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeParameters}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeParameters(@NotNull Java8Parser.TypeParametersContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeParameterList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeParameterList(@NotNull Java8Parser.TypeParameterListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#superclass}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSuperclass(@NotNull Java8Parser.SuperclassContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#superinterfaces}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSuperinterfaces(@NotNull Java8Parser.SuperinterfacesContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#interfaceTypeList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInterfaceTypeList(@NotNull Java8Parser.InterfaceTypeListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classBody}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassBody(@NotNull Java8Parser.ClassBodyContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classBodyDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassBodyDeclaration(@NotNull Java8Parser.ClassBodyDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classMemberDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassMemberDeclaration(@NotNull Java8Parser.ClassMemberDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#fieldDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitFieldDeclaration(@NotNull Java8Parser.FieldDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#fieldModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitFieldModifier(@NotNull Java8Parser.FieldModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#variableDeclaratorList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitVariableDeclaratorList(@NotNull Java8Parser.VariableDeclaratorListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#variableDeclarator}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitVariableDeclarator(@NotNull Java8Parser.VariableDeclaratorContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#variableDeclaratorId}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitVariableDeclaratorId(@NotNull Java8Parser.VariableDeclaratorIdContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#variableInitializer}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitVariableInitializer(@NotNull Java8Parser.VariableInitializerContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannType(@NotNull Java8Parser.UnannTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannPrimitiveType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannPrimitiveType(@NotNull Java8Parser.UnannPrimitiveTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannReferenceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannReferenceType(@NotNull Java8Parser.UnannReferenceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannClassOrInterfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannClassOrInterfaceType(@NotNull Java8Parser.UnannClassOrInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannClassType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannClassType(@NotNull Java8Parser.UnannClassTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannClassType_lf_unannClassOrInterfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannClassType_lf_unannClassOrInterfaceType(@NotNull Java8Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannClassType_lfno_unannClassOrInterfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannClassType_lfno_unannClassOrInterfaceType(@NotNull Java8Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannInterfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannInterfaceType(@NotNull Java8Parser.UnannInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannInterfaceType_lf_unannClassOrInterfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannInterfaceType_lf_unannClassOrInterfaceType(@NotNull Java8Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannInterfaceType_lfno_unannClassOrInterfaceType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannInterfaceType_lfno_unannClassOrInterfaceType(@NotNull Java8Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannTypeVariable}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannTypeVariable(@NotNull Java8Parser.UnannTypeVariableContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unannArrayType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnannArrayType(@NotNull Java8Parser.UnannArrayTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodDeclaration(@NotNull Java8Parser.MethodDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodModifier(@NotNull Java8Parser.MethodModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodHeader}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodHeader(@NotNull Java8Parser.MethodHeaderContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#result}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitResult(@NotNull Java8Parser.ResultContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodDeclarator}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodDeclarator(@NotNull Java8Parser.MethodDeclaratorContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#formalParameterList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitFormalParameterList(@NotNull Java8Parser.FormalParameterListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#formalParameters}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitFormalParameters(@NotNull Java8Parser.FormalParametersContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#formalParameter}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitFormalParameter(@NotNull Java8Parser.FormalParameterContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#variableModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitVariableModifier(@NotNull Java8Parser.VariableModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#lastFormalParameter}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitLastFormalParameter(@NotNull Java8Parser.LastFormalParameterContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#receiverParameter}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitReceiverParameter(@NotNull Java8Parser.ReceiverParameterContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#throws_}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitThrows_(@NotNull Java8Parser.Throws_Context ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#exceptionTypeList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitExceptionTypeList(@NotNull Java8Parser.ExceptionTypeListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#exceptionType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitExceptionType(@NotNull Java8Parser.ExceptionTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodBody}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodBody(@NotNull Java8Parser.MethodBodyContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#instanceInitializer}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInstanceInitializer(@NotNull Java8Parser.InstanceInitializerContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#staticInitializer}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitStaticInitializer(@NotNull Java8Parser.StaticInitializerContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#constructorDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitConstructorDeclaration(@NotNull Java8Parser.ConstructorDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#constructorModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitConstructorModifier(@NotNull Java8Parser.ConstructorModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#constructorDeclarator}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitConstructorDeclarator(@NotNull Java8Parser.ConstructorDeclaratorContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#simpleTypeName}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSimpleTypeName(@NotNull Java8Parser.SimpleTypeNameContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#constructorBody}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitConstructorBody(@NotNull Java8Parser.ConstructorBodyContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#explicitConstructorInvocation}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitExplicitConstructorInvocation(@NotNull Java8Parser.ExplicitConstructorInvocationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#enumDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitEnumDeclaration(@NotNull Java8Parser.EnumDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#enumBody}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitEnumBody(@NotNull Java8Parser.EnumBodyContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#enumConstantList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitEnumConstantList(@NotNull Java8Parser.EnumConstantListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#enumConstant}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitEnumConstant(@NotNull Java8Parser.EnumConstantContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#enumConstantModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitEnumConstantModifier(@NotNull Java8Parser.EnumConstantModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#enumBodyDeclarations}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitEnumBodyDeclarations(@NotNull Java8Parser.EnumBodyDeclarationsContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#interfaceDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInterfaceDeclaration(@NotNull Java8Parser.InterfaceDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#normalInterfaceDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitNormalInterfaceDeclaration(@NotNull Java8Parser.NormalInterfaceDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#interfaceModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInterfaceModifier(@NotNull Java8Parser.InterfaceModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#extendsInterfaces}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitExtendsInterfaces(@NotNull Java8Parser.ExtendsInterfacesContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#interfaceBody}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInterfaceBody(@NotNull Java8Parser.InterfaceBodyContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#interfaceMemberDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInterfaceMemberDeclaration(@NotNull Java8Parser.InterfaceMemberDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#constantDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitConstantDeclaration(@NotNull Java8Parser.ConstantDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#constantModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitConstantModifier(@NotNull Java8Parser.ConstantModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#interfaceMethodDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInterfaceMethodDeclaration(@NotNull Java8Parser.InterfaceMethodDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#interfaceMethodModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInterfaceMethodModifier(@NotNull Java8Parser.InterfaceMethodModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#annotationTypeDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAnnotationTypeDeclaration(@NotNull Java8Parser.AnnotationTypeDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#annotationTypeBody}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAnnotationTypeBody(@NotNull Java8Parser.AnnotationTypeBodyContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#annotationTypeMemberDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAnnotationTypeMemberDeclaration(@NotNull Java8Parser.AnnotationTypeMemberDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#annotationTypeElementDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAnnotationTypeElementDeclaration(@NotNull Java8Parser.AnnotationTypeElementDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#annotationTypeElementModifier}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAnnotationTypeElementModifier(@NotNull Java8Parser.AnnotationTypeElementModifierContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#defaultValue}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitDefaultValue(@NotNull Java8Parser.DefaultValueContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#annotation}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAnnotation(@NotNull Java8Parser.AnnotationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#normalAnnotation}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitNormalAnnotation(@NotNull Java8Parser.NormalAnnotationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#elementValuePairList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitElementValuePairList(@NotNull Java8Parser.ElementValuePairListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#elementValuePair}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitElementValuePair(@NotNull Java8Parser.ElementValuePairContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#elementValue}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitElementValue(@NotNull Java8Parser.ElementValueContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#elementValueArrayInitializer}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitElementValueArrayInitializer(@NotNull Java8Parser.ElementValueArrayInitializerContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#elementValueList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitElementValueList(@NotNull Java8Parser.ElementValueListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#markerAnnotation}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMarkerAnnotation(@NotNull Java8Parser.MarkerAnnotationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#singleElementAnnotation}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSingleElementAnnotation(@NotNull Java8Parser.SingleElementAnnotationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#arrayInitializer}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitArrayInitializer(@NotNull Java8Parser.ArrayInitializerContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#variableInitializerList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitVariableInitializerList(@NotNull Java8Parser.VariableInitializerListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#block}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitBlock(@NotNull Java8Parser.BlockContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#blockStatements}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitBlockStatements(@NotNull Java8Parser.BlockStatementsContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#blockStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitBlockStatement(@NotNull Java8Parser.BlockStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#localVariableDeclarationStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitLocalVariableDeclarationStatement(@NotNull Java8Parser.LocalVariableDeclarationStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#localVariableDeclaration}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitLocalVariableDeclaration(@NotNull Java8Parser.LocalVariableDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#statement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitStatement(@NotNull Java8Parser.StatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#statementNoShortIf}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitStatementNoShortIf(@NotNull Java8Parser.StatementNoShortIfContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#statementWithoutTrailingSubstatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitStatementWithoutTrailingSubstatement(@NotNull Java8Parser.StatementWithoutTrailingSubstatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#emptyStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitEmptyStatement(@NotNull Java8Parser.EmptyStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#labeledStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitLabeledStatement(@NotNull Java8Parser.LabeledStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#labeledStatementNoShortIf}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitLabeledStatementNoShortIf(@NotNull Java8Parser.LabeledStatementNoShortIfContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#expressionStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitExpressionStatement(@NotNull Java8Parser.ExpressionStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#statementExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitStatementExpression(@NotNull Java8Parser.StatementExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#ifThenStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitIfThenStatement(@NotNull Java8Parser.IfThenStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#ifThenElseStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitIfThenElseStatement(@NotNull Java8Parser.IfThenElseStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#ifThenElseStatementNoShortIf}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitIfThenElseStatementNoShortIf(@NotNull Java8Parser.IfThenElseStatementNoShortIfContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#assertStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAssertStatement(@NotNull Java8Parser.AssertStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#switchStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSwitchStatement(@NotNull Java8Parser.SwitchStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#switchBlock}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSwitchBlock(@NotNull Java8Parser.SwitchBlockContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#switchBlockStatementGroup}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSwitchBlockStatementGroup(@NotNull Java8Parser.SwitchBlockStatementGroupContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#switchLabels}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSwitchLabels(@NotNull Java8Parser.SwitchLabelsContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#switchLabel}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSwitchLabel(@NotNull Java8Parser.SwitchLabelContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#enumConstantName}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitEnumConstantName(@NotNull Java8Parser.EnumConstantNameContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#whileStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitWhileStatement(@NotNull Java8Parser.WhileStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#whileStatementNoShortIf}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitWhileStatementNoShortIf(@NotNull Java8Parser.WhileStatementNoShortIfContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#doStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitDoStatement(@NotNull Java8Parser.DoStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#forStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitForStatement(@NotNull Java8Parser.ForStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#forStatementNoShortIf}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitForStatementNoShortIf(@NotNull Java8Parser.ForStatementNoShortIfContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#basicForStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitBasicForStatement(@NotNull Java8Parser.BasicForStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#basicForStatementNoShortIf}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitBasicForStatementNoShortIf(@NotNull Java8Parser.BasicForStatementNoShortIfContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#forInit}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitForInit(@NotNull Java8Parser.ForInitContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#forUpdate}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitForUpdate(@NotNull Java8Parser.ForUpdateContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#statementExpressionList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitStatementExpressionList(@NotNull Java8Parser.StatementExpressionListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#enhancedForStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitEnhancedForStatement(@NotNull Java8Parser.EnhancedForStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#enhancedForStatementNoShortIf}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitEnhancedForStatementNoShortIf(@NotNull Java8Parser.EnhancedForStatementNoShortIfContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#breakStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitBreakStatement(@NotNull Java8Parser.BreakStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#continueStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitContinueStatement(@NotNull Java8Parser.ContinueStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#returnStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitReturnStatement(@NotNull Java8Parser.ReturnStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#throwStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitThrowStatement(@NotNull Java8Parser.ThrowStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#synchronizedStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitSynchronizedStatement(@NotNull Java8Parser.SynchronizedStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#tryStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTryStatement(@NotNull Java8Parser.TryStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#catches}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitCatches(@NotNull Java8Parser.CatchesContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#catchClause}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitCatchClause(@NotNull Java8Parser.CatchClauseContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#catchFormalParameter}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitCatchFormalParameter(@NotNull Java8Parser.CatchFormalParameterContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#catchType}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitCatchType(@NotNull Java8Parser.CatchTypeContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#finally_}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitFinally_(@NotNull Java8Parser.Finally_Context ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#tryWithResourcesStatement}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTryWithResourcesStatement(@NotNull Java8Parser.TryWithResourcesStatementContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#resourceSpecification}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitResourceSpecification(@NotNull Java8Parser.ResourceSpecificationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#resourceList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitResourceList(@NotNull Java8Parser.ResourceListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#resource}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitResource(@NotNull Java8Parser.ResourceContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPrimary(@NotNull Java8Parser.PrimaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPrimaryNoNewArray(@NotNull Java8Parser.PrimaryNoNewArrayContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_arrayAccess}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPrimaryNoNewArray_lf_arrayAccess(@NotNull Java8Parser.PrimaryNoNewArray_lf_arrayAccessContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_arrayAccess}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPrimaryNoNewArray_lfno_arrayAccess(@NotNull Java8Parser.PrimaryNoNewArray_lfno_arrayAccessContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPrimaryNoNewArray_lf_primary(@NotNull Java8Parser.PrimaryNoNewArray_lf_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(@NotNull Java8Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(@NotNull Java8Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPrimaryNoNewArray_lfno_primary(@NotNull Java8Parser.PrimaryNoNewArray_lfno_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(@NotNull Java8Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(@NotNull Java8Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classInstanceCreationExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassInstanceCreationExpression(@NotNull Java8Parser.ClassInstanceCreationExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classInstanceCreationExpression_lf_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassInstanceCreationExpression_lf_primary(@NotNull Java8Parser.ClassInstanceCreationExpression_lf_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#classInstanceCreationExpression_lfno_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitClassInstanceCreationExpression_lfno_primary(@NotNull Java8Parser.ClassInstanceCreationExpression_lfno_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#typeArgumentsOrDiamond}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitTypeArgumentsOrDiamond(@NotNull Java8Parser.TypeArgumentsOrDiamondContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#fieldAccess}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitFieldAccess(@NotNull Java8Parser.FieldAccessContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#fieldAccess_lf_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitFieldAccess_lf_primary(@NotNull Java8Parser.FieldAccess_lf_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#fieldAccess_lfno_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitFieldAccess_lfno_primary(@NotNull Java8Parser.FieldAccess_lfno_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#arrayAccess}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitArrayAccess(@NotNull Java8Parser.ArrayAccessContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#arrayAccess_lf_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitArrayAccess_lf_primary(@NotNull Java8Parser.ArrayAccess_lf_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#arrayAccess_lfno_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitArrayAccess_lfno_primary(@NotNull Java8Parser.ArrayAccess_lfno_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodInvocation}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodInvocation(@NotNull Java8Parser.MethodInvocationContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodInvocation_lf_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodInvocation_lf_primary(@NotNull Java8Parser.MethodInvocation_lf_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodInvocation_lfno_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodInvocation_lfno_primary(@NotNull Java8Parser.MethodInvocation_lfno_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#argumentList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitArgumentList(@NotNull Java8Parser.ArgumentListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodReference}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodReference(@NotNull Java8Parser.MethodReferenceContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodReference_lf_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodReference_lf_primary(@NotNull Java8Parser.MethodReference_lf_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#methodReference_lfno_primary}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMethodReference_lfno_primary(@NotNull Java8Parser.MethodReference_lfno_primaryContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#arrayCreationExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitArrayCreationExpression(@NotNull Java8Parser.ArrayCreationExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#dimExprs}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitDimExprs(@NotNull Java8Parser.DimExprsContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#dimExpr}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitDimExpr(@NotNull Java8Parser.DimExprContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#constantExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitConstantExpression(@NotNull Java8Parser.ConstantExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#expression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitExpression(@NotNull Java8Parser.ExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#lambdaExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitLambdaExpression(@NotNull Java8Parser.LambdaExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#lambdaParameters}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitLambdaParameters(@NotNull Java8Parser.LambdaParametersContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#inferredFormalParameterList}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInferredFormalParameterList(@NotNull Java8Parser.InferredFormalParameterListContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#lambdaBody}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitLambdaBody(@NotNull Java8Parser.LambdaBodyContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#assignmentExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAssignmentExpression(@NotNull Java8Parser.AssignmentExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#assignment}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAssignment(@NotNull Java8Parser.AssignmentContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#leftHandSide}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitLeftHandSide(@NotNull Java8Parser.LeftHandSideContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#assignmentOperator}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAssignmentOperator(@NotNull Java8Parser.AssignmentOperatorContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#conditionalExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitConditionalExpression(@NotNull Java8Parser.ConditionalExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#conditionalOrExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitConditionalOrExpression(@NotNull Java8Parser.ConditionalOrExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#conditionalAndExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitConditionalAndExpression(@NotNull Java8Parser.ConditionalAndExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#inclusiveOrExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitInclusiveOrExpression(@NotNull Java8Parser.InclusiveOrExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#exclusiveOrExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitExclusiveOrExpression(@NotNull Java8Parser.ExclusiveOrExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#andExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAndExpression(@NotNull Java8Parser.AndExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#equalityExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitEqualityExpression(@NotNull Java8Parser.EqualityExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#relationalExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitRelationalExpression(@NotNull Java8Parser.RelationalExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#shiftExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitShiftExpression(@NotNull Java8Parser.ShiftExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#additiveExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitAdditiveExpression(@NotNull Java8Parser.AdditiveExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#multiplicativeExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitMultiplicativeExpression(@NotNull Java8Parser.MultiplicativeExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unaryExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnaryExpression(@NotNull Java8Parser.UnaryExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#preIncrementExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPreIncrementExpression(@NotNull Java8Parser.PreIncrementExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#preDecrementExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPreDecrementExpression(@NotNull Java8Parser.PreDecrementExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#unaryExpressionNotPlusMinus}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitUnaryExpressionNotPlusMinus(@NotNull Java8Parser.UnaryExpressionNotPlusMinusContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#postfixExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPostfixExpression(@NotNull Java8Parser.PostfixExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#postIncrementExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPostIncrementExpression(@NotNull Java8Parser.PostIncrementExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#postIncrementExpression_lf_postfixExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPostIncrementExpression_lf_postfixExpression(@NotNull Java8Parser.PostIncrementExpression_lf_postfixExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#postDecrementExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPostDecrementExpression(@NotNull Java8Parser.PostDecrementExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#postDecrementExpression_lf_postfixExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitPostDecrementExpression_lf_postfixExpression(@NotNull Java8Parser.PostDecrementExpression_lf_postfixExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link Java8Parser#castExpression}. - * - * @param ctx the parse tree - * @return the visitor result - */ - Result visitCastExpression(@NotNull Java8Parser.CastExpressionContext ctx); -} diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/templates/ApplicationConfigTransformer.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/templates/ApplicationConfigTransformer.java index 7df3939..fde1929 100644 --- a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/templates/ApplicationConfigTransformer.java +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/templates/ApplicationConfigTransformer.java @@ -22,6 +22,7 @@ package org.nuiton.config.plugin.templates; * #L% */ +import com.google.common.base.Joiner; import com.google.common.collect.ImmutableSet; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -30,15 +31,21 @@ import org.nuiton.config.ApplicationConfig; import org.nuiton.config.ApplicationConfigInit; import org.nuiton.config.ApplicationConfigProvider; import org.nuiton.config.ConfigActionDef; +import org.nuiton.config.ConfigOptionDef; +import org.nuiton.config.plugin.model.ActionModel; +import org.nuiton.config.plugin.model.ConfigModel; +import org.nuiton.config.plugin.model.OptionModel; import org.nuiton.eugene.GeneratorUtil; import org.nuiton.eugene.java.JavaGeneratorUtil; import org.nuiton.eugene.java.ObjectModelTransformerToJava; -import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModel; import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelEnumeration; import org.nuiton.eugene.models.object.ObjectModelJavaModifier; import org.nuiton.eugene.models.object.ObjectModelOperation; import org.nuiton.i18n.I18n; +import java.util.List; import java.util.Locale; import java.util.Set; @@ -56,50 +63,269 @@ import java.util.Set; public class ApplicationConfigTransformer extends ObjectModelTransformerToJava { private static final Log log = LogFactory.getLog(ApplicationConfigTransformer.class); - public static final String PROP_OPTION_CLASS_NAME = "optionClassName"; - public static final String PROP_ACTION_CLASS_NAME = "actionClassName"; - public static final String PROP_GENERATE_PROVIDER = "generateProvider"; + + public static final String PROP_CONFIG = "config"; + private ApplicationConfigTransformerConfig config; @Override - public void transformFromClass(ObjectModelClass clazz) { + public void transformFromModel(ObjectModel model) { + super.transformFromModel(model); + config = getConfiguration().getProperty(PROP_CONFIG, ApplicationConfigTransformerConfig.class); + + ConfigModel configModel = config.getConfigModel(); + + boolean useNuitonI18n = config.isUseNuitonI18n(); + + String packageName = config.getPackageName(); + String configClassName = config.getConfigClassName(); + String configProviderClassName = config.getConfigProviderClassName(); + String optionsClassName = config.getOptionsClassName(); + List<OptionModel> options = configModel.getOptions(); - String packageName = clazz.getPackageName(); - String abstractClassName = "Generated" + clazz.getName(); + String actionsClassName = config.getActionsClassName(); + List<ActionModel> actions = configModel.getActions(); - String optionClassName = getProperty(PROP_OPTION_CLASS_NAME); - String actionClassName = getProperty(PROP_ACTION_CLASS_NAME); + String abstractClassName = "Generated" + configClassName; - generateAbstractClass(packageName, abstractClassName, clazz, optionClassName, actionClassName); + generateConfigAbstractClass(packageName, abstractClassName, optionsClassName, actionsClassName, options); - String className = clazz.getName(); - if (canGenerate(packageName + "." + className)) { + if (canGenerate(packageName + "." + configClassName)) { - generateClass(packageName, className, abstractClassName); + generateConfigClass(packageName, configClassName, abstractClassName); } else { if (log.isDebugEnabled()) { - log.debug("Skip generation for " + className); + log.debug("Skip generation for " + configClassName); + } + + } + + if (config.isGenerateProvider()) { + + String abstractProviderClassName = "Generated" + configProviderClassName; + generateProviderAbstractClass(packageName, abstractProviderClassName, configClassName, optionsClassName, actionsClassName, useNuitonI18n, configModel.getDescription()); + + if (canGenerate(packageName + "." + configProviderClassName)) { + + generateProviderClass(packageName, abstractProviderClassName, configProviderClassName); + + } + + } + + if (canGenerate(packageName + "." + optionsClassName)) { + generateOptionsClass(packageName, useNuitonI18n, optionsClassName, options); + } + + if (canGenerate(packageName + "." + actionsClassName)) { + generateActionsClass(packageName, actionsClassName, actions); + } + + + } + + private void generateOptionsClass(String packageName, boolean useNuitonI18n, String optionsClassName, List<OptionModel> options) { + + ObjectModelEnumeration output = createEnumeration(optionsClassName, packageName); + addInterface(output, ConfigOptionDef.class); + if (useNuitonI18n) { + addImport(output, I18n.class); + } + for (OptionModel option : options) { + + String literalName = GeneratorUtil.convertVariableNameToConstantName(option.getName()); + + String defaultValue = option.getDefaultValue(); + if (defaultValue != null) { + defaultValue = "\"" + defaultValue + "\""; + } + String description = "\"" + option.getDescription() + "\""; + if (useNuitonI18n) { + description = "I18n.n(" + description + ")"; } + String literal = "" + /*{ + <%=literalName%>( + <%=option.getType()%>.class, + "<%=option.getKey()%>", + <%=description%>, + <%=defaultValue%>, + <%=option.isTransient()%>, + <%=option.isFinal()%>)}*/; + + addLiteral(output, literal); } - String generateProvider = getProperty(PROP_GENERATE_PROVIDER); - if (generateProvider != null && Boolean.TRUE.equals(Boolean.valueOf(generateProvider))) { + addAttribute(output, "type", Class.class, null, ObjectModelJavaModifier.PRIVATE, ObjectModelJavaModifier.FINAL); + addAttribute(output, "key", String.class, null, ObjectModelJavaModifier.PRIVATE, ObjectModelJavaModifier.FINAL); + addAttribute(output, "description", String.class, null, ObjectModelJavaModifier.PRIVATE, ObjectModelJavaModifier.FINAL); + addAttribute(output, "defaultValue", String.class, null, ObjectModelJavaModifier.PRIVATE); + addAttribute(output, "_transient", boolean.class, null, ObjectModelJavaModifier.PRIVATE); + addAttribute(output, "_final", boolean.class, null, ObjectModelJavaModifier.PRIVATE); + + ObjectModelOperation constructor = addConstructor(output, ObjectModelJavaModifier.PACKAGE); + addParameter(constructor, Class.class, "type"); + addParameter(constructor, String.class, "key"); + addParameter(constructor, String.class, "description"); + addParameter(constructor, String.class, "defaultValue"); + addParameter(constructor, boolean.class, "_transient"); + addParameter(constructor, boolean.class, "_final"); + setOperationBody(constructor, "" + /*{ + this.type = type; + this.key = key; + this.description = description; + this.defaultValue = defaultValue; + this._final = _final; + this._transient = _transient; + }*/ + ); + + ObjectModelOperation getKey = addOperation( + output, "getKey", String.class, ObjectModelJavaModifier.PUBLIC); + addAnnotation(output, getKey, Override.class); + setOperationBody(getKey, "" + /*{ + return key; + }*/ + ); + ObjectModelOperation getType = addOperation( + output, "getType", Class.class, ObjectModelJavaModifier.PUBLIC); + addAnnotation(output, getType, Override.class); + setOperationBody(getType, "" + /*{ + return type; + }*/ + ); + ObjectModelOperation getDescription = addOperation( + output, "getDescription", String.class, ObjectModelJavaModifier.PUBLIC); + addAnnotation(output, getDescription, Override.class); + String descriptionValue = "description"; + if (useNuitonI18n) { + descriptionValue = "I18n.t(" + descriptionValue + ")"; + } + setOperationBody(getDescription, "" + /*{ + return <%=descriptionValue%>; + }*/ + ); + + ObjectModelOperation getDefaultValue = addOperation( + output, "getDefaultValue", String.class, ObjectModelJavaModifier.PUBLIC); + addAnnotation(output, getDefaultValue, Override.class); + setOperationBody(getDefaultValue, "" + /*{ + return defaultValue; + }*/ + ); + + ObjectModelOperation setDefaultValue = addOperation( + output, "setDefaultValue", void.class, ObjectModelJavaModifier.PUBLIC); + addParameter(setDefaultValue, String.class, "defaultValue"); + addAnnotation(output, setDefaultValue, Override.class); + setOperationBody(setDefaultValue, "" + /*{ + this.defaultValue = defaultValue; + }*/ + ); + - String abstractProviderClassName = "Generated" + className + "Provider"; - generateAbstractProvider(packageName, abstractProviderClassName, className, optionClassName, actionClassName); + ObjectModelOperation isTransient = addOperation( + output, "isTransient", boolean.class, ObjectModelJavaModifier.PUBLIC); + addAnnotation(output, isTransient, Override.class); + setOperationBody(isTransient, "" + /*{ + return _transient; + }*/ + ); + + ObjectModelOperation setTransient = addOperation( + output, "setTransient", void.class, ObjectModelJavaModifier.PUBLIC); + addParameter(setTransient, boolean.class, "_transient"); + addAnnotation(output, setTransient, Override.class); + setOperationBody(setTransient, "" + /*{ + this._transient = _transient; + }*/ + ); + + ObjectModelOperation isFinal = addOperation( + output, "isFinal", boolean.class, ObjectModelJavaModifier.PUBLIC); + addAnnotation(output, isFinal, Override.class); + setOperationBody(isFinal, "" + /*{ + return _final; + }*/ + ); + + ObjectModelOperation setFinal = addOperation( + output, "setFinal", void.class, ObjectModelJavaModifier.PUBLIC); + addParameter(setFinal, boolean.class, "_final"); + addAnnotation(output, setFinal, Override.class); + setOperationBody(setFinal, "" + /*{ + this._final = _final; + }*/ + ); + + } + + private void generateActionsClass(String packageName, String actionsClassName, List<ActionModel> actions) { - String providerClassName = className + "Provider"; - if (canGenerate(packageName + "." + providerClassName)) { - generateProvider(packageName, abstractProviderClassName, providerClassName, className); + ObjectModelEnumeration output = createEnumeration(actionsClassName, packageName); + addInterface(output, ConfigActionDef.class); + for (ActionModel action : actions) { + + String literalName = GeneratorUtil.convertVariableNameToConstantName(action.getName()); + + String aliases = ""; + if (action.getAliases().length > 0) { + aliases = ", \"" + Joiner.on("\", \"").join(action.getAliases()) + "\""; } + String literal = "" + /*{ + <%=literalName%> ( "<%=action.getAction()%>"<%=aliases%> )}*/; + + addLiteral(output, literal); } + + addAttribute(output, "action", String.class, null, ObjectModelJavaModifier.PRIVATE, ObjectModelJavaModifier.FINAL); + addAttribute(output, "aliases", "String[]", null, ObjectModelJavaModifier.PRIVATE, ObjectModelJavaModifier.FINAL); + + ObjectModelOperation constructor = addConstructor(output, ObjectModelJavaModifier.PACKAGE); + addParameter(constructor, String.class, "action"); + addParameter(constructor, "String...", "aliases"); + setOperationBody(constructor, "" + /*{ + this.action = action; + this.aliases = aliases; + }*/ + ); + + ObjectModelOperation getAction = addOperation( + output, "getAction", String.class, ObjectModelJavaModifier.PUBLIC); + addAnnotation(output, getAction, Override.class); + setOperationBody(getAction, "" + /*{ + return action; + }*/ + ); + ObjectModelOperation getAliases = addOperation( + output, "getAliases", "String[]", ObjectModelJavaModifier.PUBLIC); + addAnnotation(output, getAliases, Override.class); + setOperationBody(getAliases, "" + /*{ + return aliases; + }*/ + ); + } - private void generateAbstractProvider(String packageName, String providerClassName, String className, String optionClassName, String actionClassName) { + private void generateProviderAbstractClass(String packageName, String providerClassName, String className, String optionClassName, String actionClassName, boolean useNuitonI18n, String description) { ObjectModelClass output = createAbstractClass(providerClassName, packageName); addInterface(output, ApplicationConfigProvider.class); @@ -153,9 +379,23 @@ public class ApplicationConfigTransformer extends ObjectModelTransformerToJava { ); } + String descriptionValue = "\"" + description + "\""; + if (useNuitonI18n) { + descriptionValue = "I18n.l(locale, " + descriptionValue + ")"; + } + ObjectModelOperation getDescription = addOperation( + output, "getDescription", String.class, ObjectModelJavaModifier.PUBLIC); + addParameter(getDescription, Locale.class, "locale"); + addAnnotation(output, getDescription, Override.class); + + setOperationBody(getDescription, "" + /*{ + return <%=descriptionValue%>; + }*/ + ); } - private void generateProvider(String packageName, String abstractProviderClassName, String providerClassName, String className) { + private void generateProviderClass(String packageName, String abstractProviderClassName, String providerClassName) { ObjectModelClass output = createClass(providerClassName, packageName); setSuperClass(output, abstractProviderClassName); @@ -165,19 +405,10 @@ public class ApplicationConfigTransformer extends ObjectModelTransformerToJava { log.info("Generate " + output.getQualifiedName()); } - ObjectModelOperation getDescription = addOperation( - output, "getDescription", String.class, ObjectModelJavaModifier.PUBLIC); - addParameter(getDescription, Locale.class, "locale"); - addAnnotation(output, getDescription, Override.class); - setOperationBody(getDescription, "" - /*{ - return I18n.l(locale, "<%=className%>.description"); - }*/ - ); } - private void generateAbstractClass(String packageName, String abstractClassName, ObjectModelClass input, String optionClassName, String actionClassName) { + private void generateConfigAbstractClass(String packageName, String abstractClassName, String optionClassName, String actionClassName, List<OptionModel> options) { String optionClassSimpleName = GeneratorUtil.getSimpleName(optionClassName); @@ -244,34 +475,23 @@ public class ApplicationConfigTransformer extends ObjectModelTransformerToJava { }*/ ); - for (ObjectModelAttribute attribute : input.getAttributes()) { + for (OptionModel option : options) { - String attrName = attribute.getName(); - String attrType = attribute.getType(); + String attrName = option.getName(); + String attrType = option.getType(); String simpleType = JavaGeneratorUtil.getSimpleName(attrType); String constantName = JavaGeneratorUtil.getSimpleName(optionClassName) + "." + JavaGeneratorUtil.convertVariableNameToConstantName(attrName); addImport(output, attrType); - // generate getter - createGetMethod(output, - attrName, - simpleType, - constantName); - - - // generate setter - createSetMethod(output, - attrName, - simpleType, - constantName - ); + createGetMethod(output, attrName, simpleType, constantName); + createSetMethod(output, attrName, simpleType, constantName); } } - private void generateClass(String packageName, String className, String abstractClassName) { + private void generateConfigClass(String packageName, String className, String abstractClassName) { ObjectModelClass output = createClass(className, packageName); if (log.isInfoEnabled()) { diff --git a/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExample.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/templates/ApplicationConfigTransformerConfig.java similarity index 56% copy from nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExample.java copy to nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/templates/ApplicationConfigTransformerConfig.java index 4835f3c..6571c2e 100644 --- a/nuiton-config-example/src/main/java/org/nuiton/config/example/NuitonConfigExample.java +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/templates/ApplicationConfigTransformerConfig.java @@ -1,8 +1,8 @@ -package org.nuiton.config.example; +package org.nuiton.config.plugin.templates; /*- * #%L - * Nuiton Config :: Example + * Nuiton Config :: Maven plugin * %% * Copyright (C) 2016 Code Lutin, Tony Chemit * %% @@ -22,27 +22,32 @@ package org.nuiton.config.example; * #L% */ +import org.nuiton.config.plugin.model.ConfigModel; + /** - * Created on 30/09/16. + * Created on 01/10/16. * * @author Tony Chemit - chemit@codelutin.com + * @since 3.0 */ -public class NuitonConfigExample { +public interface ApplicationConfigTransformerConfig { + + ConfigModel getConfigModel(); + + String getModelName(); + + String getPackageName(); - public static void main(String... args) throws Exception { + String getConfigClassName(); - NuitonConfigExampleConfig config = new NuitonConfigExampleConfig(); + boolean isGenerateProvider(); - config.get().parse(args); + boolean isUseNuitonI18n(); - System.out.println("Configuration file name : " + config.getConfigFile()); - System.out.println("Application data directory : " + config.getDataDirectory()); - System.out.println("Application db directory : " + config.getDbDirectory()); + String getConfigProviderClassName(); - } + String getOptionsClassName(); - public void help() { - System.out.println("Aide."); - } + String getActionsClassName(); } diff --git a/nuiton-config-maven-plugin/src/test/java/org/nuiton/config/plugin/parser/yml/ConfigModelReaderTest.java b/nuiton-config-maven-plugin/src/test/java/org/nuiton/config/plugin/parser/yml/ConfigModelReaderTest.java new file mode 100644 index 0000000..9844c6f --- /dev/null +++ b/nuiton-config-maven-plugin/src/test/java/org/nuiton/config/plugin/parser/yml/ConfigModelReaderTest.java @@ -0,0 +1,94 @@ +package org.nuiton.config.plugin.parser.yml; + +/*- + * #%L + * Nuiton Config :: Maven plugin + * %% + * Copyright (C) 2016 Code Lutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. + * #L% + */ + +import org.junit.Assert; +import org.junit.Test; +import org.nuiton.config.plugin.model.ActionModel; +import org.nuiton.config.plugin.model.ConfigModel; +import org.nuiton.config.plugin.model.ConfigModelReader; +import org.nuiton.config.plugin.model.OptionModel; + +import java.io.File; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.List; + +/** + * Created by tchemit on 01/10/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ConfigModelReaderTest { + + @Test + public void read() throws Exception { + + Path path = Paths.get(new File("").getAbsolutePath(), "src", "test", "resources", "NuitonConfigExample.yml"); + + ConfigModel configModel = ConfigModelReader.read(path); + Assert.assertNotNull(configModel); + Assert.assertEquals("Exemple de configuration", configModel.getDescription()); + + List<OptionModel> options = configModel.getOptions(); + Assert.assertNotNull(options); + Assert.assertEquals(5, options.size()); + + assertOption(options.get(0), "identity.firstName", "Prénom de l'utilisateur", String.class, "Joshua"); + assertOption(options.get(1), "identity.lastName", "Nom de l'utilisateur", String.class, "Bloch"); + assertOption(options.get(2), "identity.email", "Courriel de l'utilisateur", String.class, null); + assertOption(options.get(3), "identity.twitter", "Compte Twitter de l'utilisateur", String.class, "jbloch"); + assertOption(options.get(4), "identity.age", "age de l'utilisateur", int.class, "56"); + + List<ActionModel> actions = configModel.getActions(); + Assert.assertNotNull(actions); + Assert.assertEquals(1, actions.size()); + assertAction(actions.get(0), "help", "Pour afficher l'aide", "org.nuiton.config.example.NuitonConfigExample#help", "-h", "--help"); + + } + + private void assertOption(OptionModel optionModel, String expectedKey, String expectedDescpription, Class<?> expectedType, String expectedDefaultValue) { + Assert.assertNotNull(optionModel); + Assert.assertNotNull(optionModel); + + Assert.assertNotNull(optionModel.getKey()); + Assert.assertEquals(expectedKey, optionModel.getKey()); + Assert.assertNotNull(optionModel.getDescription()); + Assert.assertEquals(expectedDescpription, optionModel.getDescription()); + Assert.assertNotNull(optionModel.getType()); + Assert.assertEquals(expectedType.getName(), optionModel.getType()); + Assert.assertEquals(expectedDefaultValue, optionModel.getDefaultValue()); + } + + private void assertAction(ActionModel actionModel, String expectedName, String expectedDescription, String expectedAction, String... expectedAliases) { + Assert.assertNotNull(actionModel); + + Assert.assertNotNull(actionModel.getName()); + Assert.assertEquals(expectedName, actionModel.getName()); + Assert.assertNotNull(actionModel.getDescription()); + Assert.assertEquals(expectedDescription, actionModel.getDescription()); + Assert.assertNotNull(actionModel.getAction()); + Assert.assertEquals(expectedAction, actionModel.getAction()); + Assert.assertArrayEquals(expectedAliases, actionModel.getAliases()); + } +} diff --git a/nuiton-config-maven-plugin/src/test/resources/NuitonConfigExample.yml b/nuiton-config-maven-plugin/src/test/resources/NuitonConfigExample.yml new file mode 100644 index 0000000..9d74f30 --- /dev/null +++ b/nuiton-config-maven-plugin/src/test/resources/NuitonConfigExample.yml @@ -0,0 +1,39 @@ +description: Exemple de configuration +options: + - !option + name: firstName + key: identity.firstName + type: string + description: Prénom de l'utilisateur + defaultValue: Joshua + - !option + name: lastName + key: identity.lastName + type: string + description: Nom de l'utilisateur + defaultValue: Bloch + - !option + name: email + key: identity.email + type: string + description: Courriel de l'utilisateur + - !option + name: twitter + key: identity.twitter + type: string + description: Compte Twitter de l'utilisateur + defaultValue: jbloch + - !option + name: age + key: identity.age + type: int + description: age de l'utilisateur + defaultValue: 56 +actions: + - !action + name: help + description: Pour afficher l'aide + action: org.nuiton.config.example.NuitonConfigExample#help + aliases: + - "-h" + - "--help" \ No newline at end of file diff --git a/pom.xml b/pom.xml index d83df1a..631497c 100644 --- a/pom.xml +++ b/pom.xml @@ -166,9 +166,10 @@ </dependency> <dependency> - <groupId>com.tunnelvisionlabs</groupId> - <artifactId>antlr4-runtime</artifactId> - <version>4.5.3</version> + <groupId>com.esotericsoftware.yamlbeans</groupId> + <artifactId>yamlbeans</artifactId> + <!--Ne pas utiliser la version 1.09 elle est buggée--> + <version>1.08</version> </dependency> <dependency> -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.