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 b6b1286c728827c3be4ac367ab476bd0462f423b Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Sep 30 12:27:15 2016 +0200 Add mavne plugin module with generate and report mojos --- nuiton-config-maven-plugin/LICENSE.txt | 165 + nuiton-config-maven-plugin/README.md | 2 + nuiton-config-maven-plugin/pom.xml | 226 + .../src/license/THIRD-PARTY.properties | 37 + .../nuiton/config/plugin/AggregateReportMojo.java | 72 + .../org/nuiton/config/plugin/GenerateMojo.java | 404 + .../java/org/nuiton/config/plugin/ReportMojo.java | 56 + .../nuiton/config/plugin/ReportMojoSupport.java | 284 + .../org/nuiton/config/plugin/ReportRenderer.java | 476 + .../plugin/parser/java/Java8BaseVisitor.java | 2644 +++ .../config/plugin/parser/java/Java8Lexer.java | 611 + .../config/plugin/parser/java/Java8Parser.java | 19733 +++++++++++++++++++ .../config/plugin/parser/java/Java8Visitor.java | 1932 ++ .../templates/ApplicationConfigTransformer.java | 314 + .../src/main/resources/log4j.properties | 30 + nuiton-config-maven-plugin/src/site/apt/index.apt | 37 + nuiton-config-maven-plugin/src/site/site_fr.xml | 48 + pom.xml | 176 +- 18 files changed, 27245 insertions(+), 2 deletions(-) diff --git a/nuiton-config-maven-plugin/LICENSE.txt b/nuiton-config-maven-plugin/LICENSE.txt new file mode 100644 index 0000000..cca7fc2 --- /dev/null +++ b/nuiton-config-maven-plugin/LICENSE.txt @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/nuiton-config-maven-plugin/README.md b/nuiton-config-maven-plugin/README.md new file mode 100644 index 0000000..d2e50d3 --- /dev/null +++ b/nuiton-config-maven-plugin/README.md @@ -0,0 +1,2 @@ +To deploy new version of pom: mvn deploy +To install localy: mvn install diff --git a/nuiton-config-maven-plugin/pom.xml b/nuiton-config-maven-plugin/pom.xml new file mode 100644 index 0000000..ceb7d09 --- /dev/null +++ b/nuiton-config-maven-plugin/pom.xml @@ -0,0 +1,226 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + #%L + EUGene :: Maven plugin + + $HeadURL$ + %% + Copyright (C) 2006 - 2010 CodeLutin + %% + 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% + --> + +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>org.nuiton</groupId> + <artifactId>nuiton-config-project</artifactId> + <version>3.0-SNAPSHOT</version> + </parent> + + <artifactId>nuiton-config-maven-plugin</artifactId> + <packaging>maven-plugin</packaging> + + <name>Nuiton Config :: Maven plugin</name> + <description>Maven plugin to use the config library</description> + <inceptionYear>2016</inceptionYear> + + <properties> + + <!-- Post Release configuration --> + <skipPostRelease>false</skipPostRelease> + + </properties> + + <dependencies> + + <dependency> + <groupId>${project.groupId}</groupId> + <artifactId>nuiton-config</artifactId> + <version>${project.version}</version> + </dependency> + + <dependency> + <groupId>org.nuiton.eugene</groupId> + <artifactId>eugene</artifactId> + </dependency> + + <dependency> + <groupId>org.nuiton</groupId> + <artifactId>nuiton-version</artifactId> + </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> + + <dependency> + <groupId>commons-logging</groupId> + <artifactId>commons-logging</artifactId> + </dependency> + + <dependency> + <groupId>commons-io</groupId> + <artifactId>commons-io</artifactId> + </dependency> + + <dependency> + <groupId>com.google.guava</groupId> + <artifactId>guava</artifactId> + </dependency> + + <dependency> + <groupId>org.apache.maven</groupId> + <artifactId>maven-plugin-api</artifactId> + </dependency> + + <dependency> + <groupId>org.apache.maven</groupId> + <artifactId>maven-core</artifactId> + </dependency> + + <dependency> + <groupId>org.apache.maven</groupId> + <artifactId>maven-model</artifactId> + </dependency> + + <dependency> + <groupId>org.apache.maven</groupId> + <artifactId>maven-artifact</artifactId> + </dependency> + + <dependency> + <groupId>org.apache.maven</groupId> + <artifactId>maven-settings</artifactId> + </dependency> + + <dependency> + <groupId>org.apache.maven.plugin-tools</groupId> + <artifactId>maven-plugin-annotations</artifactId> + </dependency> + + <dependency> + <groupId>org.codehaus.plexus</groupId> + <artifactId>plexus-utils</artifactId> + </dependency> + + <dependency> + <groupId>org.nuiton</groupId> + <artifactId>helper-maven-plugin-api</artifactId> + </dependency> + + <dependency> + <groupId>org.apache.maven.reporting</groupId> + <artifactId>maven-reporting-api</artifactId> + </dependency> + <dependency> + <groupId>org.apache.maven.reporting</groupId> + <artifactId>maven-reporting-impl</artifactId> + </dependency> + + <dependency> + <groupId>org.codehaus.plexus</groupId> + <artifactId>plexus-i18n</artifactId> + </dependency> + + <!-- doxia --> + + <dependency> + <groupId>org.apache.maven.doxia</groupId> + <artifactId>doxia-core</artifactId> + </dependency> + + <dependency> + <groupId>org.apache.maven.doxia</groupId> + <artifactId>doxia-site-renderer</artifactId> + </dependency> + + <dependency> + <groupId>org.apache.maven.doxia</groupId> + <artifactId>doxia-sink-api</artifactId> + </dependency> + + <dependency> + <groupId>xml-apis</groupId> + <artifactId>xml-apis</artifactId> + </dependency> + + <dependency> + <groupId>log4j</groupId> + <artifactId>log4j</artifactId> + <scope>runtime</scope> + </dependency> + + </dependencies> + + <build> + <pluginManagement> + <plugins> + + <plugin> + <artifactId>maven-plugin-plugin</artifactId> + <configuration> + <skipErrorNoDescriptorsFound>true</skipErrorNoDescriptorsFound> + </configuration> + <executions> + <execution> + <goals> + <goal>helpmojo</goal> + <goal>descriptor</goal> + </goals> + </execution> + </executions> + </plugin> + + </plugins> + </pluginManagement> + <plugins> + + <plugin> + <groupId>org.nuiton.processor</groupId> + <artifactId>processor-maven-plugin</artifactId> + <executions> + <execution> + <phase>generate-sources</phase> + <goals> + <goal>process</goal> + </goals> + </execution> + </executions> + <configuration> + <includes>**/*.java</includes> + <filters> + org.nuiton.processor.filters.GeneratorTemplatesFilter + </filters> + </configuration> + </plugin> + + </plugins> + </build> + +</project> diff --git a/nuiton-config-maven-plugin/src/license/THIRD-PARTY.properties b/nuiton-config-maven-plugin/src/license/THIRD-PARTY.properties new file mode 100644 index 0000000..fc3ffd2 --- /dev/null +++ b/nuiton-config-maven-plugin/src/license/THIRD-PARTY.properties @@ -0,0 +1,37 @@ +# Generated by org.codehaus.mojo.license.AddThirdPartyMojo +#------------------------------------------------------------------------------- +# Already used licenses in project : +# - Apache License +# - Apache License Version 2.0 +# - Apache Software License, Version 1.1 +# - BSD License +# - COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0 +# - Eclipse Public License 1.0 +# - Eclipse Public License, Version 1.0 +# - Indiana University Extreme! Lab Software License, vesion 1.1.1 +# - Lesser General Public License (LGPL) v 3.0 +# - Lesser General Public License (LPGL) +# - Lesser General Public License (LPGL) v 2.1 +# - MIT License +# - Mozilla Public License Version 1.0 +# - New BSD License +# - Public Domain +# - The Apache Software License, Version 2.0 +# - The GNU General Public License +# - The SAX License +# - The W3C License +# - http://classworlds.codehaus.org/license.html +# - http://jaxen.codehaus.org/license.html +#------------------------------------------------------------------------------- +# Please fill the missing licenses for dependencies : +# +# +#Sun Aug 09 09:53:01 CEST 2015 +antlr--antlr--2.7.2=BSD License +classworlds--classworlds--1.1-alpha-2=http\://classworlds.codehaus.org/license.html +commons-primitives--commons-primitives--1.0=The Apache Software License, Version 2.0 +dom4j--dom4j--1.1=BSD License +org.codehaus.plexus--plexus-container-default--1.0-alpha-9-stable-1=The Apache Software License, Version 2.0 +org.codehaus.plexus--plexus-i18n--1.0-beta-10=The Apache Software License, Version 2.0 +org.codehaus.plexus--plexus-velocity--1.1.7=The Apache Software License, Version 2.0 +oro--oro--2.0.8=The Apache Software License, Version 2.0 diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/AggregateReportMojo.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/AggregateReportMojo.java new file mode 100644 index 0000000..680bce0 --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/AggregateReportMojo.java @@ -0,0 +1,72 @@ +package org.nuiton.config.plugin; + +/* + * #%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.apache.maven.artifact.DependencyResolutionRequiredException; +import org.apache.maven.plugins.annotations.Execute; +import org.apache.maven.plugins.annotations.LifecyclePhase; +import org.apache.maven.plugins.annotations.Mojo; +import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.plugins.annotations.ResolutionScope; +import org.apache.maven.project.MavenProject; +import org.apache.maven.reporting.MavenReportException; +import org.nuiton.config.ApplicationConfigProvider; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +/** + * Generates a report for declared application config via the + * {@link ApplicationConfigProvider} mechanism on a aggregate mojo. + * <p> + * For each configuration, you can find all his options and actions. + * + * @author Tony - chemit@codelutin.com + * @since 3.0 + */ +@Mojo(name = "aggregate-report", aggregator = true, requiresReports = true, requiresDependencyResolution = ResolutionScope.RUNTIME) +@Execute(phase = LifecyclePhase.COMPILE) +public class AggregateReportMojo extends ReportMojoSupport { + + /** + * The projects in the reactor. + */ + @Parameter(property = "reactorProjects", readonly = true, required = true) + private List<MavenProject> reactorProjects; + + @Override + protected ClassLoader createClassLoader() throws MavenReportException { + Set<String> paths = new HashSet<>(); + + for (MavenProject p : reactorProjects) { + try { + List<String> runtimeClasspathElements = p.getRuntimeClasspathElements(); + paths.addAll(runtimeClasspathElements); + } catch (DependencyResolutionRequiredException e) { + throw new MavenReportException("Could not obtain dependencies for project " + p); + } + } + return createClassLoader(paths); + } +} 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 new file mode 100644 index 0000000..d6ec93d --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/GenerateMojo.java @@ -0,0 +1,404 @@ +package org.nuiton.config.plugin; + +/* + * #%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.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.plugin.MojoExecutionException; +import org.apache.maven.plugins.annotations.LifecyclePhase; +import org.apache.maven.plugins.annotations.Mojo; +import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.plugins.annotations.ResolutionScope; +import org.apache.maven.project.MavenProject; +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.templates.ApplicationConfigTransformer; +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.Date; +import java.util.LinkedHashMap; +import java.util.Locale; +import java.util.Map; +import java.util.Properties; + +/** + * Generate application config java files from the option definition class. + * <p> + * Created on 28/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.0 + */ +@Mojo(name = "generate", defaultPhase = LifecyclePhase.GENERATE_SOURCES, requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME) +public class GenerateMojo extends AbstractPlugin implements PluginWithEncoding { + + /** + * To set the package fully qualified name of the generated class. + * <p> + * By default, will use groupId.artifactId (with {@code -} replaced by {@code .}) plus {@code .config}. + */ + @Parameter(property = "config.packageName") + private String packageName; + + /** + * Model name (will prefix the generated files names with it). + */ + @Parameter(property = "config.modelName", required = true) + private String modelName; + + /** + * The fully qualified name of the enum class of options to scan to generate the configuration java files. + * <p> + * By default, will use groupId.artifactId (with {@code -} replaced by {@code .}) plus {@code .config.modelNameOption}. + */ + @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. + * <p> + * By default, will use groupId.artifactId (with {@code -} replaced by {@code .}) plus {@code .config.modelNameAction}. + */ + @Parameter(property = "config.actionsClassName") + private String actionsClassName; + + /** + * The source directory where to scan options java file. + */ + @Parameter(property = "config.sourceDirectory", defaultValue = "${basedir}/src/main/java", required = true) + private File sourceDirectory; + + /** + * The root directory where to generated. + */ + @Parameter(property = "config.outputdirectory", defaultValue = "${basedir}/target/generated-sources/java", required = true) + private File outputdirectory; + + /** + * Pour activer le mode verbeux. + */ + @Parameter(property = "config.verbose", defaultValue = "${maven.verbose}") + private boolean verbose; + + /** + * Encoding to be used for generation of files. + * <p> + * <b>Note:</b> If nothing is filled here, we will use the system + * property {@code file.encoding}. + */ + @Parameter(property = "config.encoding", defaultValue = "${project.build.sourceEncoding}") + private String encoding; + + /** + * + */ + @Parameter(property = "config.prefix", defaultValue = "Config") + private String prefix; + + /** + * Maven project. + */ + @Parameter(defaultValue = "${project}", readonly = true) + private MavenProject project; + + private ObjectModelImpl model; + + private ApplicationConfigTransformer template; + + @Override + protected void init() throws Exception { + + if (packageName == null) { + + packageName = getProject().getGroupId() + "." + getProject().getArtifactId().replaceAll("-", "."); + getLog().info("Use package name: " + packageName); + } + + 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 (!javaFile.exists()) { + + prefix = "Configuration"; + + optionsClassName = packageName + "." + modelName + prefix + "Option"; + + file = PluginHelper.getFile(sourceDirectory, optionsClassName.split("\\.")); + javaFile = new File(file.getParentFile(), file.getName() + ".java"); + + if (!javaFile.exists()) { + throw new MojoExecutionException("Can't find option file at: " + javaFile); + } + } + getLog().info("Detected configuration options class: " + optionsClassName); + + } + + if (actionsClassName == null) { + + actionsClassName = packageName + "." + modelName + prefix + "Action"; + + File file = PluginHelper.getFile(sourceDirectory, actionsClassName.split("\\.")); + File javaFile = new File(file.getParentFile(), file.getName() + ".java"); + + if (javaFile.exists()) { + + getLog().info("Detected configuration actions class: " + actionsClassName); + } else { + + // won't be used + actionsClassName = null; + } + + } + + ClassLoader loader = this.initClassLoader(getProject(), sourceDirectory, true, false, false, true, true); + + // get options + + model = new ObjectModelImpl(); + model.setName(modelName); + + + String className = modelName + prefix; + getLog().info("Config class name: " + className); + + 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(className); + 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); + } + + 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_OPTION_CLASS_NAME, optionsClassName); + if (actionsClassName != null) { + templateProperties.put(ApplicationConfigTransformer.PROP_ACTION_CLASS_NAME, actionsClassName); + } + + template = new ApplicationConfigTransformer(); + template.setConfiguration(new DefaultTemplateConfiguration(templateProperties)); + + if (!project.getCompileSourceRoots().contains(outputdirectory.getPath())) { + if (isVerbose()) { + getLog().info("Add compile source root : " + outputdirectory); + } + project.addCompileSourceRoot(outputdirectory.getPath()); + } + } + + @Override + protected void doAction() throws Exception { + + getLog().info("Generate file(s) to: " + outputdirectory); + + template.applyTemplate(model, outputdirectory); + + } + + @Override + public boolean isVerbose() { + return verbose; + } + + @Override + public void setVerbose(boolean verbose) { + this.verbose = verbose; + } + + @Override + public MavenProject getProject() { + return project; + } + + @Override + public String getEncoding() { + return encoding; + } + + @Override + public void setEncoding(String encoding) { + this.encoding = encoding; + } + + @Override + public void setProject(MavenProject project) { + this.project = project; + } + + private class JavaParserVisitor extends Java8BaseVisitor<Void> { + + private final Map<String, String> names; + + private final ClassLoader loader; + final File file; + + private JavaParserVisitor(ClassLoader loader, File file) { + this.loader = loader; + this.file = file; + this.names = new LinkedHashMap<>(); + } + + Map<String, String> getNames() { + return names; + } + + String name; + boolean first; + + @Override + public Void visitEnumConstant(Java8Parser.EnumConstantContext ctx) { + name = ctx.getChild(0).getText(); + first = false; + return super.visitEnumConstant(ctx); + } + + @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); + } + + } + +} diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/ReportMojo.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/ReportMojo.java new file mode 100644 index 0000000..2be698e --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/ReportMojo.java @@ -0,0 +1,56 @@ +package org.nuiton.config.plugin; + +/* + * #%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.apache.maven.plugins.annotations.Mojo; +import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.plugins.annotations.ResolutionScope; +import org.nuiton.config.ApplicationConfigProvider; + +import java.util.HashSet; +import java.util.List; + +/** + * Generates a report for declared application config via the + * {@link ApplicationConfigProvider} mechanism. + * <p> + * For each configuration, you can find all his options and actions. + * + * @author Tony - chemit@codelutin.com + * @since 3.0 + */ +@Mojo(name = "report", requiresReports = true, requiresDependencyResolution = ResolutionScope.RUNTIME) +public class ReportMojo extends ReportMojoSupport { + + /** + * List of all class-path elements. + */ + @Parameter(property = "project.runtimeClasspathElements", required = true, readonly = true) + private List<String> runtimeClasspathElements; + + @Override + protected ClassLoader createClassLoader() { + return createClassLoader(new HashSet<>(runtimeClasspathElements)); + } + +} diff --git a/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/ReportMojoSupport.java b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/ReportMojoSupport.java new file mode 100644 index 0000000..bb6a9d9 --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/ReportMojoSupport.java @@ -0,0 +1,284 @@ +package org.nuiton.config.plugin; + +/* + * #%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.apache.maven.doxia.siterenderer.Renderer; +import org.apache.maven.plugins.annotations.Component; +import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.project.MavenProject; +import org.apache.maven.reporting.AbstractMavenReport; +import org.apache.maven.reporting.MavenReportException; +import org.codehaus.plexus.i18n.I18N; +import org.codehaus.plexus.util.StringUtils; +import org.nuiton.config.ApplicationConfigHelper; +import org.nuiton.config.ApplicationConfigProvider; +import org.nuiton.i18n.I18n; +import org.nuiton.i18n.init.ClassPathI18nInitializer; +import org.nuiton.i18n.init.DefaultI18nInitializer; +import org.nuiton.i18n.init.I18nInitializer; + +import java.io.File; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Locale; +import java.util.Set; + +/** + * Abstract application config report used by normal and aggregate report. + * + * @author Tony - chemit@codelutin.com + * @since 3.0 + */ +abstract class ReportMojoSupport extends AbstractMavenReport { + + /** + * Report output directory. Note that this parameter is only relevant if the goal is run from the command line or + * from the default build lifecycle. If the goal is run indirectly as part of a site generation, the output + * directory configured in the Maven Site Plugin is used instead. + */ + @Parameter(property = "config.outputDirectory", defaultValue = "${project.reporting.outputDirectory}", required = true) + private File outputDirectory; + + /** + * Report output encoding. Note that this parameter is only relevant if the goal is run from the command line or + * from the default build lifecycle. If the goal is run indirectly as part of a site generation, the output + * encoding configured in the Maven Site Plugin is used instead. + */ + @Parameter(property = "config.outputEncoding", defaultValue = "${project.reporting.outputEncoding}", required = true) + protected String outputEncoding; + + /** + * Optional i18n bundle name as used by the nuiton I18n system to init his + * files. + * <p> + * If not given, will look at all i18n files in all over class-path (which + * could be costy if many dependencies), otherwise will init I18n system + * usinga {@link DefaultI18nInitializer} with this bundle name. + */ + @Parameter(property = "config.i18nBundleName") + private String i18nBundleName; + + /** + * List of application config to include in report (separated by comma). + * <p> + * <strong>Note:</strong> If not filled then will use all config + * found in class-path. + */ + @Parameter(property = "config.include") + private String include; + + /** + * List of application config to exclude from report (separated by comma). + * <p> + * <strong>Note:</strong> If not filled no config will be exclude. + */ + @Parameter(property = "config.exclude") + private String exclude; + + /** + * Flag to activate verbose mode. + * <p> + * <b>Note:</b> Verbose mode is always on if you starts a debug maven instance + * (says via {@code -X}). + */ + @Parameter(property = "config.verbose", defaultValue = "${maven.verbose}") + private boolean verbose; + + /** + * Flag to render option in detail (add a section for each option). + */ + @Parameter(property = "config.showOptionDetail", defaultValue = "true") + private boolean showOptionDetail; + + /** + * Skip to generate the report. + */ + @Parameter(property = "config.skip") + private boolean skip; + + /** + * The Maven Project. + */ + @Parameter(defaultValue = "${project}", required = true) + private MavenProject project; + + /** + * Doxia Site Renderer component. + */ + @Component + private Renderer siteRenderer; + + /** + * Internationalization component. + */ + @Component + private I18N i18n; + + /** + * Class loader with all compile dependencies of the module in class-path + * (used to init i18n) and obtain config provider over compile class-path. + */ + private ClassLoader newClassLoader; + + /** + * Set of ApplicationConfigProvider detected from configuration. + */ + private Set<ApplicationConfigProvider> configProviders; + + @Override + public String getOutputName() { + return "config-report"; + } + + public String getDescription(Locale locale) { + return i18n.getString(getOutputName(), locale, "report.description"); + } + + public String getName(Locale locale) { + return i18n.getString(getOutputName(), locale, "report.title"); + } + + @Override + public String getCategoryName() { + return CATEGORY_PROJECT_REPORTS; + } + + @Override + public boolean canGenerateReport() { + return !skip; + } + + @Override + protected Renderer getSiteRenderer() { + return siteRenderer; + } + + @Override + protected String getOutputDirectory() { + return outputDirectory.getAbsolutePath(); + } + + @Override + protected MavenProject getProject() { + return project; + } + + protected abstract ClassLoader createClassLoader() throws MavenReportException; + + @Override + protected void executeReport(Locale locale) throws MavenReportException { + + if (newClassLoader == null) { + + // not init + init(locale); + } else { + + // just change init language + I18n.setDefaultLocale(locale); + } + ReportRenderer renderer = + new ReportRenderer(getSink(), + i18n, + locale, + getOutputName(), + getOutputName(), + configProviders, + showOptionDetail); + renderer.render(); + } + + private void init(Locale locale) throws MavenReportException { + if (getLog().isDebugEnabled()) { + + // debug mode set verbose flag to true + verbose = true; + } + + if (newClassLoader == null) { + + newClassLoader = createClassLoader(); + } + + // get i18n initializer + I18nInitializer initializer; + if (StringUtils.isNotEmpty(i18nBundleName)) { + initializer = new DefaultI18nInitializer(i18nBundleName, + newClassLoader); + } else { + initializer = new ClassPathI18nInitializer(newClassLoader); + } + // init i18n + I18n.init(initializer, locale); + + if (configProviders == null) { + + Set<String> includes = null; + if (StringUtils.isNotEmpty(include)) { + includes = new HashSet<>(Arrays.asList(include.split("\\s*,\\s*"))); + if (verbose) { + getLog().info("config - includes : " + includes); + } + } + + Set<String> excludes = null; + if (StringUtils.isNotEmpty(exclude)) { + excludes = new HashSet<>(Arrays.asList(exclude.split("\\s*,\\s*"))); + if (verbose) { + getLog().info("config - excludes : " + excludes); + } + } + + configProviders = ApplicationConfigHelper.getProviders( + newClassLoader, + includes, + excludes, + verbose + ); + } + } + + ClassLoader createClassLoader(Set<String> paths) { + + Set<URL> urls = new HashSet<>(); + + for (String fileName : paths) { + File pathElem = new File(fileName); + try { + URL url = pathElem.toURI().toURL(); + urls.add(url); + getLog().debug("Added classpathElement URL " + url); + } catch (MalformedURLException e) { + throw new RuntimeException( + "Error in adding the classpath " + pathElem, e); + } + } + + return new URLClassLoader( + urls.toArray(new URL[urls.size()]), + Thread.currentThread().getContextClassLoader()); + } +} 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 new file mode 100644 index 0000000..023f39c --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/ReportRenderer.java @@ -0,0 +1,476 @@ +package org.nuiton.config.plugin; + +/* + * #%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.apache.commons.collections.CollectionUtils; +import org.apache.maven.doxia.sink.Sink; +import org.apache.maven.doxia.sink.SinkEventAttributeSet; +import org.apache.maven.doxia.sink.SinkEventAttributes; +import org.apache.maven.reporting.AbstractMavenReportRenderer; +import org.codehaus.plexus.i18n.I18N; +import org.codehaus.plexus.util.StringUtils; +import org.nuiton.config.ApplicationConfigProvider; +import org.nuiton.config.ConfigActionDef; +import org.nuiton.config.ConfigOptionDef; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Locale; +import java.util.Set; + +import static org.nuiton.i18n.I18n.l; + +/** + * Render the {@link ReportMojo} report. + * + * @author Tony - chemit@codelutin.com + * @since 3.0 + */ +class ReportRenderer extends AbstractMavenReportRenderer { + + /** + * Internationalization component. + */ + private final I18N i18n; + + /** + * The locale we are rendering for. + */ + private final Locale locale; + + /** + * The report physical name (used to generated link). + */ + private final String reportName; + + /** + * The name of the bundle containing our I18n resources. + */ + private final String bundleName; + + /** + * Set of config providers to generate. + */ + private final Set<ApplicationConfigProvider> configProviders; + + /** + * To show option in detail. + */ + private final boolean optionWithDetail; + + ReportRenderer(Sink sink, + I18N i18n, + Locale locale, + String reportName, + String bundleName, + Set<ApplicationConfigProvider> configProviders, + boolean optionWithDetail) { + super(sink); + this.i18n = i18n; + this.locale = locale; + this.reportName = reportName; + this.bundleName = bundleName; + this.sink = sink; + this.configProviders = configProviders; + this.optionWithDetail = optionWithDetail; + } + + @Override + public String getTitle() { + return getText("report.title"); + } + + @Override + public void renderBody() { + + sink.section1(); + sink.sectionTitle1(); + sink.text(getText("report.overview.title")); + sink.sectionTitle1_(); + sink.lineBreak(); + sink.paragraph(); + sink.text(getText("report.overview.text")); + sink.paragraph_(); + + sink.paragraph(); + sink.link("http://doc.nuiton.org/nuiton-config/index.html"); + sink.text(getText("report.overview.more.information")); + sink.link_(); + sink.paragraph_(); + sink.lineBreak(); + + renderProviderSummaryTable(); + + sink.section1_(); + + if (CollectionUtils.isNotEmpty(configProviders)) { + + sink.section1(); + sink.sectionTitle1(); + sink.text(getText("report.detail.title")); + sink.sectionTitle1_(); + sink.lineBreak(); + sink.paragraph(); + sink.text(getText("report.detail.text")); + sink.paragraph_(); + + for (ApplicationConfigProvider configProvider : configProviders) { + + renderConfigProviderDetail(configProvider); + } + + sink.section1_(); + } + } + + private void renderProviderSummaryTable() { + + if (CollectionUtils.isEmpty(configProviders)) { + + sink.text(getText("report.detail.text.noConfig")); + + } else { + sink.table(); + + sink.tableRow(); + sinkHeaderCellText(getText("report.config.name")); + sinkHeaderCellText(getText("report.config.description")); + sinkHeaderCellText(getText("report.config.nbOptions")); + sinkHeaderCellText(getText("report.config.nbActions")); + sink.tableRow_(); + + for (ApplicationConfigProvider configProvider : configProviders) { + + sink.tableRow(); + sinkCellLink(configProvider.getName(), "detail_" + configProvider.getName()); + sinkCellText(configProvider.getDescription(locale)); + sinkCellText(configProvider.getOptions().length + ""); + sinkCellText(configProvider.getActions().length + ""); + sink.tableRow_(); + } + sink.table_(); + } + } + + private void renderConfigProviderDetail(ApplicationConfigProvider configProvider) { + + sink.section2(); + sink.sectionTitle2(); + sink.anchor("detail_" + configProvider.getName()); + sink.text(getText("report.detail.configuration.title") + " " + + configProvider.getName()); + sink.anchor_(); + sink.sectionTitle2_(); + + sink.lineBreak(); + sink.paragraph(); + sink.text(getText("report.config.name") + " : "); + sink.bold(); + sink.text(configProvider.getName()); + sink.bold_(); + sink.paragraph_(); + + sink.lineBreak(); + sink.paragraph(); + sink.text(getText("report.config.description") + " : "); + sink.bold(); + sink.text(configProvider.getDescription(locale)); + sink.bold_(); + sink.paragraph_(); + + sink.section3(); + sink.sectionTitle3(); + sink.anchor("detail_options_" + configProvider.getName()); + + sink.text(getText("report.detail.options.title")); + sink.anchor_(); + sink.sectionTitle3_(); + sink.lineBreak(); + + Collection<ConfigOptionDef> options = + getOptions(configProvider); + + renderOptionDefsTable(configProvider, options); + + if (optionWithDetail) { + + for (ConfigOptionDef option : options) { + + renderProviderOptionDetail(configProvider, option); + } + } + + sink.section3_(); + + sink.section3(); + sink.sectionTitle3(); + sink.text(getText("report.detail.actions.title")); + sink.sectionTitle3_(); + sink.lineBreak(); + + renderActionDefsTable(configProvider.getActions()); + + sink.section3_(); + + sink.section2_(); + } + + private void renderOptionDefsTable(ApplicationConfigProvider configProvider, Collection<ConfigOptionDef> options) { + + if (options.isEmpty()) { + + sink.paragraph(); + sink.bold(); + sink.text(getText("report.detail.options.noOptions")); + sink.bold_(); + sink.paragraph_(); + + } else { + + sink.table(); + sink.tableRow(); + + sinkHeaderCellText(getText("report.config.option.key")); + sinkHeaderCellText(getText("report.config.option.description")); + if (!optionWithDetail) { + sinkHeaderCellText(getText("report.config.option.type")); + } + sinkHeaderCellText(getText("report.config.option.defaultValue")); + + if (!optionWithDetail) { + sinkHeaderCellText(getText("report.config.option.final")); + sinkHeaderCellText(getText("report.config.option.transient")); + } + sink.tableRow_(); + + for (ConfigOptionDef option : options) { + + sink.tableRow(); + if (optionWithDetail) { + sinkCellLink( + option.getKey(), + "detail_" + configProvider.getName() + "_" + option.getKey()); + } else { + sinkCellText(option.getKey()); + } + sinkCellText(l(locale, option.getDescription())); + if (!optionWithDetail) { + sinkCellText(option.getType().getName()); + } + sinkCellVerbatimText(getDefaultValue(option)); + if (!optionWithDetail) { + sinkCellText(getText(!option.isFinal())); + sinkCellText(getText(!option.isTransient())); + } + sink.tableRow_(); + } + + sink.table_(); + + } + } + + private void renderActionDefsTable(ConfigActionDef... actions) { + + if (actions.length == 0) { + + sink.paragraph(); + sink.bold(); + sink.text(getText("report.detail.actions.noActions")); + sink.bold_(); + sink.paragraph_(); + + } else { + + sink.table(); + + sink.tableRow(); + sinkHeaderCellText(getText("report.config.action.action")); + sinkHeaderCellText(getText("report.config.action.aliases")); + sink.tableRow_(); + + for (ConfigActionDef action : actions) { + sink.tableRow(); + sinkCellText(action.getAction()); + sinkCellText(l(locale, Arrays.toString(action.getAliases()))); + sink.tableRow_(); + } + + sink.table_(); + } + } + + private void renderProviderOptionDetail(ApplicationConfigProvider configProvider, + ConfigOptionDef option) { + + final SinkEventAttributes cellWidth = new SinkEventAttributeSet(); + cellWidth.addAttribute(SinkEventAttributes.WIDTH, "80%"); + + final SinkEventAttributes headerWidth = new SinkEventAttributeSet(); + headerWidth.addAttribute(SinkEventAttributes.WIDTH, "20%"); +// final String cellWidth = "80%"; +// final String headerWidth = "20%"; + + sink.section4(); + sink.sectionTitle4(); + sink.anchor("detail_" + configProvider.getName() + "_" + option.getKey()); + sink.text(getText("report.config.option.detail") + " '" + option.getKey() + + "'"); + sink.sectionTitle4_(); + sink.lineBreak(); + + sink.table(); + sink.tableRows(new int[]{Sink.JUSTIFY_RIGHT, Sink.JUSTIFY_LEFT}, false); + + sink.tableRow(); + sinkHeaderCellText(headerWidth, getText("report.config.option.key")); + sink.tableCell(cellWidth); + sink.nonBreakingSpace(); + sink.bold(); + sink.text(option.getKey()); + sink.bold_(); + sink.tableCell_(); + sink.tableRow_(); + + sink.tableRow(); + sinkHeaderCellText(headerWidth, getText("report.config.option.description")); + sink.tableCell(cellWidth); + sink.nonBreakingSpace(); + sink.text(l(locale, option.getDescription())); + sink.tableCell_(); + sink.tableRow_(); + + sink.tableRow(); + sinkHeaderCellText(headerWidth, getText("report.config.option.defaultValue")); + sink.tableCell(cellWidth); + sink.nonBreakingSpace(); + sink.bold(); + sink.text(getDefaultValue(option)); + sink.bold_(); + sink.tableCell_(); + sink.tableRow_(); + + sink.tableRow(); + sinkHeaderCellText(headerWidth, getText("report.config.option.type")); + sink.tableCell(cellWidth); + sink.nonBreakingSpace(); + sink.text(option.getType().getName()); + sink.tableCell_(); + sink.tableRow_(); + + sink.tableRow(); + sinkHeaderCellText(headerWidth, getText("report.config.option.final")); + sink.tableCell(cellWidth); + sink.nonBreakingSpace(); + sink.text(getText(!option.isFinal())); + sink.tableCell_(); + sink.tableRow_(); + + sink.tableRow(); + sinkHeaderCellText(headerWidth, getText("report.config.option.transient")); + sink.tableCell(cellWidth); + sink.nonBreakingSpace(); + sink.text(getText(!option.isTransient())); + sink.tableCell_(); + sink.tableRow_(); + + sink.table_(); + + sink.paragraph(); + sinkLinkToAnchor(getText("report.back.options.table"), "detail_options_" + configProvider.getName()); + sink.paragraph_(); + + sink.section4_(); + + } + + private String getText(boolean key) { + return getText("report." + String.valueOf(key)); + } + + private String getText(String key) { + return i18n.getString(bundleName, locale, key); + } + + private String getDefaultValue(ConfigOptionDef option) { + String defaultValue = option.getDefaultValue(); + if (StringUtils.isBlank(defaultValue)) { + defaultValue = getText("report.noDefaultValue"); + } + return defaultValue; + } + + private void sinkHeaderCellText(String text) { + sink.tableHeaderCell(); + sink.text(text); + sink.tableHeaderCell_(); + } + + private void sinkHeaderCellText(SinkEventAttributes width, String text) { + sink.tableHeaderCell(width); + sink.text(text); + sink.tableHeaderCell_(); + } + + private void sinkCellText(String text) { + sink.tableCell(); + sink.text(text); + sink.tableCell_(); + } + + private void sinkCellVerbatimText(String text) { + sink.tableCell(); + sink.verbatim(SinkEventAttributeSet.MONOSPACED); + sink.text(text); + sink.verbatim_(); + sink.tableCell_(); + } + + private void sinkCellLink(String text, String url) { + sink.tableCell(); + sinkLinkToAnchor(text, url); + sink.tableCell_(); + } + + private void sinkLinkToAnchor(String text, String anchor) { + sink.link("./" + reportName + ".html#" + anchor); + sink.text(text); + sink.link_(); + } + + private Collection<ConfigOptionDef> getOptions(ApplicationConfigProvider configProvider) { + List<ConfigOptionDef> result = new ArrayList<>(Arrays.asList(configProvider.getOptions())); + Collections.sort(result, new Comparator<ConfigOptionDef>() { + @Override + public int compare(ConfigOptionDef o1, + ConfigOptionDef o2) { + return o1.getKey().compareTo(o2.getKey()); + } + }); + return result; + } +} 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 new file mode 100644 index 0000000..78e9821 --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8BaseVisitor.java @@ -0,0 +1,2644 @@ +// 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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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> + * <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 new file mode 100644 index 0000000..d652952 --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Lexer.java @@ -0,0 +1,611 @@ +// 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 new file mode 100644 index 0000000..e2bbd32 --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Parser.java @@ -0,0 +1,19733 @@ +// 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 new file mode 100644 index 0000000..d353b25 --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/parser/java/Java8Visitor.java @@ -0,0 +1,1932 @@ +// 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 new file mode 100644 index 0000000..7960111 --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/java/org/nuiton/config/plugin/templates/ApplicationConfigTransformer.java @@ -0,0 +1,314 @@ +package org.nuiton.config.plugin.templates; + +/*- + * #%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.google.common.collect.ImmutableSet; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.codehaus.plexus.util.StringUtils; +import org.nuiton.config.ApplicationConfig; +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.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelJavaModifier; +import org.nuiton.eugene.models.object.ObjectModelOperation; + +import java.util.Set; + +/*{generator option: parentheses = false}*/ +/*{generator option: writeString = +}*/ + +/** + * To generate configuration java files from the options enum file. + * <p> + * Created on 15/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.0 + */ +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"; + + @Override + public void transformFromClass(ObjectModelClass clazz) { + + String packageName = clazz.getPackageName(); + String abstractClassName = "Generated" + clazz.getName(); + + if (canGenerate(packageName + "." + abstractClassName)) { + + generateAbstractClass(packageName, abstractClassName, clazz); + + } else { + + if (log.isDebugEnabled()) { + log.debug("Skip generation for " + abstractClassName); + } + + } + + String className = clazz.getName(); + if (canGenerate(packageName + "." + className)) { + + generateClass(packageName, className, abstractClassName); + + } else { + + if (log.isDebugEnabled()) { + log.debug("Skip generation for " + className); + } + + } + } + + private void generateAbstractClass(String packageName, String abstractClassName, ObjectModelClass input) { + + String optionClassName = getProperty(PROP_OPTION_CLASS_NAME); + String optionClassSimpleName = GeneratorUtil.getSimpleName(optionClassName); + + String actionClassName = getProperty(PROP_ACTION_CLASS_NAME); + + ObjectModelClass output = createAbstractClass(abstractClassName, packageName); + + addInterface(output, "java.util.function.Supplier<ApplicationConfig>"); + addImport(output, "java.util.function.Supplier"); + addImport(output, optionClassName); + + if (log.isInfoEnabled()) { + log.info("Generate " + output.getQualifiedName()); + } + addAttribute(output, "applicationConfig", ApplicationConfig.class, "", ObjectModelJavaModifier.PRIVATE); + + ObjectModelOperation constructor = addConstructor(output, ObjectModelJavaModifier.PROTECTED); + StringBuilder builder = new StringBuilder(); + builder.append("" + /*{ + this.applicationConfig = new ApplicationConfig(); + this.applicationConfig.loadDefaultOptions(<%=optionClassSimpleName%>.values()); + }*/ + ); + if (actionClassName != null) { + addImport(output, actionClassName); + String actionClassSimpleName = GeneratorUtil.getSimpleName(actionClassName); + builder.append("" + /*{ + for (<%=actionClassSimpleName%> a : <%=actionClassSimpleName%>.values()) { + + for (String alias : a.getAliases()) { + applicationConfig.addActionAlias(alias, a.getAction()); + } + } + }*/ + ); + } + setOperationBody(constructor, builder.toString()); + + ObjectModelOperation getApplicationConfig = addOperation( + output, "get", ApplicationConfig.class, ObjectModelJavaModifier.PUBLIC); + addAnnotation(output, getApplicationConfig, Override.class); + setOperationBody(getApplicationConfig, "" + /*{ + return applicationConfig; + }*/ + ); + + ObjectModelOperation setOption = addOperation( + output, "setOption", "void", ObjectModelJavaModifier.PROTECTED); + addParameter(setOption, String.class, "key"); + addParameter(setOption, Object.class, "attrName"); + + setOperationBody(setOption, "" + /*{ + applicationConfig.setOption(key, String.valueOf(attrName)); + }*/ + ); + + for (ObjectModelAttribute attribute : input.getAttributes()) { + + String attrName = attribute.getName(); + String attrType = attribute.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 + ); + + } + + } + + private void generateClass(String packageName, String className, String abstractClassName) { + + ObjectModelClass output = createClass(className, packageName); + if (log.isInfoEnabled()) { + log.info("Generate " + output.getQualifiedName()); + } + setSuperClass(output, abstractClassName); + + } + + private boolean canGenerate(String input) { + return !getResourcesHelper().isJavaFileInClassPath(input); + } + + private static final Set<String> KNOWN_TYPES = ImmutableSet.of( + "File", + "Color", + "KeyStroke", + "URL", + "Class", + "Date", + "Time", + "Timestamp", + "Locale", + "Version", + "String", + "int", + "Integer", + "long", + "Long", + "float", + "Float", + "boolean", + "Boolean", + "byte", + "Byte", + "char", + "Character", + "double", + "Double"); + + private void createGetMethod(ObjectModelClass output, + String attrName, + String simpleType, + String constantName) { + + boolean booleanProperty = GeneratorUtil.isBooleanPrimitive(simpleType); + String methodPrefix = booleanProperty ? JavaGeneratorUtil.OPERATION_GETTER_BOOLEAN_PREFIX : JavaGeneratorUtil.OPERATION_GETTER_DEFAULT_PREFIX; + + String methodName = "getOptionAs" + StringUtils.capitalise(simpleType); + if (simpleType.equals("String")) { + methodName = "getOption"; + } else if (simpleType.equals("Integer")) { + methodName = "getOptionAsInt"; + } + + ObjectModelOperation operation = addOperation( + output, + getJavaBeanMethodName(methodPrefix, attrName), + simpleType, + ObjectModelJavaModifier.PUBLIC + ); + + if (!KNOWN_TYPES.contains(simpleType)) { + methodName = "getOptionAsObject"; + setOperationBody(operation, "" + /*{ + return (<%=simpleType%>) applicationConfig.<%=methodName%>(<%=simpleType%>.class, <%=constantName%>.getKey()); + }*/ + ); + } else + + { + setOperationBody(operation, "" + /*{ + return applicationConfig.<%=methodName%>(<%=constantName%>.getKey()); + }*/ + ); + + if ("Boolean".equals(simpleType)) { + operation = addOperation( + output, + getJavaBeanMethodName(JavaGeneratorUtil.OPERATION_GETTER_BOOLEAN_PREFIX, attrName), + "boolean", + ObjectModelJavaModifier.PUBLIC + ); + + setOperationBody(operation, "" + /*{ + return applicationConfig.<%=methodName%>(<%=constantName%>.getKey()); + }*/ + ); + } + } + } + + private void createSetMethod(ObjectModelClass output, + String attrName, + String simpleType, + String constantName) { + boolean booleanProperty = GeneratorUtil.isBooleanPrimitive(simpleType); + ObjectModelOperation operation = addOperation( + output, + getJavaBeanMethodName("set", attrName), + "void", + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, simpleType, attrName); + + String methodPrefix = booleanProperty ? JavaGeneratorUtil.OPERATION_GETTER_BOOLEAN_PREFIX : JavaGeneratorUtil.OPERATION_GETTER_DEFAULT_PREFIX; + String methodName = getJavaBeanMethodName(methodPrefix, attrName); + setOperationBody(operation, "" + /*{ + setOption(<%=constantName%>.getKey(), <%=attrName%>); + }*/ + ); + + if ("Boolean".equals(simpleType)) { + operation = addOperation( + output, + getJavaBeanMethodName("set", attrName), + "void", + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, "boolean", attrName); + + setOperationBody(operation, "" + /*{ + setOption(<%=constantName%>.getKey(), <%=attrName%>); + }*/ + ); + } + + + } + +} diff --git a/nuiton-config-maven-plugin/src/main/resources/log4j.properties b/nuiton-config-maven-plugin/src/main/resources/log4j.properties new file mode 100644 index 0000000..61f28db --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/resources/log4j.properties @@ -0,0 +1,30 @@ +### +# #%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% +### +# Global logging configuration +log4j.rootLogger=WARN, stdout +# Console output... +log4j.appender.stdout=org.apache.log4j.ConsoleAppender +log4j.appender.stdout.layout=org.apache.log4j.PatternLayout +log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) %M - %m%n +# package level +log4j.logger.org.nuiton=INFO +log4j.logger.org.nuiton.config=INFO diff --git a/nuiton-config-maven-plugin/src/site/apt/index.apt b/nuiton-config-maven-plugin/src/site/apt/index.apt new file mode 100644 index 0000000..090f760 --- /dev/null +++ b/nuiton-config-maven-plugin/src/site/apt/index.apt @@ -0,0 +1,37 @@ +.. - +.. * #%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% +.. - + + ---- + Nuiton Config Maven Plugin + ---- + ---- + 2016-09-30 + ---- + + +Présentation + + TODO + +Utilisation + + Voir la page des {{{./plugin-info.html} détails des goals}}. diff --git a/nuiton-config-maven-plugin/src/site/site_fr.xml b/nuiton-config-maven-plugin/src/site/site_fr.xml new file mode 100644 index 0000000..7fb58ef --- /dev/null +++ b/nuiton-config-maven-plugin/src/site/site_fr.xml @@ -0,0 +1,48 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + #%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% + --> + +<project name="${project.name}" + xmlns="http://maven.apache.org/DECORATION/1.4.0" + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/DECORATION/1.4.0 http://maven.apache.org/xsd/decoration-1.4.0.xsd"> + + <bannerLeft> + <name>${project.name}</name> + </bannerLeft> + + <body> + + <breadcrumbs> + <item name="${project.name}" href="./index.html"/> + </breadcrumbs> + + <menu ref="parent"/> + + <menu name="Utilisateur"> + <item href="index.html" name="Présentation"/> + </menu> + + <menu ref="reports"/> + + </body> +</project> diff --git a/pom.xml b/pom.xml index 658898b..82ea73d 100644 --- a/pom.xml +++ b/pom.xml @@ -47,6 +47,7 @@ <modules> <module>nuiton-config</module> + <module>nuiton-config-maven-plugin</module> </modules> <scm> @@ -61,10 +62,15 @@ <projectId>nuiton-config</projectId> <ciViewId>nuiton-config</ciViewId> - <javaVersion>1.6</javaVersion> - <signatureArtifactId>java16</signatureArtifactId> + <javaVersion>1.7</javaVersion> + <signatureArtifactId>java17</signatureArtifactId> <signatureVersion>1.0</signatureVersion> + <antlr4Version>4.5</antlr4Version> + <mavenVersion>3.3.9</mavenVersion> + <eugeneVersion>3.0-SNAPSHOT</eugeneVersion> + <doxiaVersion>1.5</doxiaVersion> + <!-- Documentation is in apt format --> <siteSourcesType>apt</siteSourcesType> <locales>fr</locales> @@ -91,6 +97,25 @@ </dependency> <dependency> + <groupId>org.nuiton.eugene</groupId> + <artifactId>eugene</artifactId> + <version>${eugeneVersion}</version> + <scope>compile</scope> + </dependency> + + <dependency> + <groupId>org.nuiton</groupId> + <artifactId>helper-maven-plugin-api</artifactId> + <version>${helperPluginVersion}</version> + </dependency> + + <dependency> + <groupId>com.google.guava</groupId> + <artifactId>guava</artifactId> + <version>19.0</version> + </dependency> + + <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.4</version> @@ -134,6 +159,153 @@ <scope>provided</scope> </dependency> + <!-- see http://stackoverflow.com/a/32918434/2038100 --> + <dependency> + <groupId>com.tunnelvisionlabs</groupId> + <artifactId>antlr4-runtime</artifactId> + <version>${antlr4Version}</version> + </dependency> + <dependency> + <groupId>com.tunnelvisionlabs</groupId> + <artifactId>antlr4-annotations</artifactId> + <version>${antlr4Version}</version> + </dependency> + + <dependency> + <groupId>org.codehaus.plexus</groupId> + <artifactId>plexus-utils</artifactId> + <version>3.0.24</version> + </dependency> + + <dependency> + <groupId>org.apache.maven</groupId> + <artifactId>maven-plugin-api</artifactId> + <version>${mavenVersion}</version> + <scope>compile</scope> + </dependency> + + <dependency> + <groupId>org.apache.maven</groupId> + <artifactId>maven-core</artifactId> + <version>${mavenVersion}</version> + <scope>provided</scope> + </dependency> + + <dependency> + <groupId>org.apache.maven</groupId> + <artifactId>maven-model</artifactId> + <version>${mavenVersion}</version> + <scope>provided</scope> + </dependency> + + <dependency> + <groupId>org.apache.maven</groupId> + <artifactId>maven-artifact</artifactId> + <version>${mavenVersion}</version> + <scope>provided</scope> + </dependency> + + <dependency> + <groupId>org.apache.maven</groupId> + <artifactId>maven-settings</artifactId> + <version>${mavenVersion}</version> + <scope>provided</scope> + </dependency> + + <dependency> + <groupId>org.apache.maven.plugin-tools</groupId> + <artifactId>maven-plugin-annotations</artifactId> + <version>${pluginPluginVersion}</version> + <scope>provided</scope> + </dependency> + + <dependency> + <groupId>org.apache.maven.reporting</groupId> + <artifactId>maven-reporting-api</artifactId> + <version>3.0</version> + </dependency> + <dependency> + <groupId>org.apache.maven.reporting</groupId> + <artifactId>maven-reporting-impl</artifactId> + <version>2.4</version> + <exclusions> + <exclusion> + <groupId>org.apache.maven</groupId> + <artifactId>maven-project</artifactId> + </exclusion> + </exclusions> + </dependency> + + <dependency> + <groupId>org.codehaus.plexus</groupId> + <artifactId>plexus-i18n</artifactId> + <version>1.0-beta-10</version> + <exclusions> + <exclusion> + <groupId>org.codehaus.plexus</groupId> + <artifactId>plexus-component-api</artifactId> + </exclusion> + </exclusions> + </dependency> + + + <!-- doxia --> + + <dependency> + <groupId>org.apache.maven.doxia</groupId> + <artifactId>doxia-core</artifactId> + <version>${doxiaVersion}</version> + <exclusions> + <exclusion> + <groupId>org.codehaus.plexus</groupId> + <artifactId>plexus-container-default</artifactId> + </exclusion> + </exclusions> + </dependency> + + <dependency> + <groupId>org.apache.maven.doxia</groupId> + <artifactId>doxia-site-renderer</artifactId> + <version>1.4</version> + <exclusions> + <exclusion> + <groupId>org.codehaus.plexus</groupId> + <artifactId>plexus-container-default</artifactId> + </exclusion> + <exclusion> + <groupId>velocity</groupId> + <artifactId>velocity</artifactId> + </exclusion> + </exclusions> + </dependency> + + <dependency> + <groupId>org.apache.maven.doxia</groupId> + <artifactId>doxia-sink-api</artifactId> + <version>${doxiaVersion}</version> + </dependency> + + <dependency> + <groupId>xml-apis</groupId> + <artifactId>xml-apis</artifactId> + <version>2.0.2</version> + <scope>provided</scope> + </dependency> + </dependencies> </dependencyManagement> + + <build> + + <pluginManagement> + <plugins> + <plugin> + <groupId>org.nuiton.processor</groupId> + <artifactId>processor-maven-plugin</artifactId> + <version>1.3</version> + </plugin> + </plugins> + </pluginManagement> + + </build> </project> -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.

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 4cc41e12fcf68eb8a3d53a075ae04046dd351f39 Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Sep 30 12:34:04 2016 +0200 Add report bundle --- .../src/main/resources/config-report.properties | 51 ++++++++++++++++++++++ .../src/main/resources/config-report_en.properties | 21 +++++++++ .../src/main/resources/config-report_fr.properties | 49 +++++++++++++++++++++ 3 files changed, 121 insertions(+) diff --git a/nuiton-config-maven-plugin/src/main/resources/config-report.properties b/nuiton-config-maven-plugin/src/main/resources/config-report.properties new file mode 100644 index 0000000..6301781 --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/resources/config-report.properties @@ -0,0 +1,51 @@ +### +# #%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% +### +report.title=Configuration +report.description=Provides details of configuration options useable on the project. +report.overview.title=Overview +report.overview.text=This report summarizes all configuration options useable on the project. +report.detail.text.noConfig=No configuration found in class-path. +report.config.name=Name of configuration +report.noDefaultValue=No default value +report.config.description=Description +report.config.nbOptions=Number of options +report.config.nbActions=Number of actions +report.config.option.key=Key +report.config.option.description=Description +report.config.option.type=Type +report.config.option.defaultValue=Default Value +report.config.option.final=Can be modified +report.config.option.transient=Can be saved +report.config.option.detail=Details of option +report.overview.more.information=More information about ApplicationConfig +report.true=Yes +report.false=No +report.back.options.table=Back to options table +report.detail.title=Detail of configurations +report.detail.text=We give details of each configuration of the project +report.detail.configuration.title=Configuration +report.detail.options.title=Configuration options +report.detail.actions.title=Configuration actions +report.detail.options.noOptions=No option found for this configuration +report.detail.actions.noActions=No action found for this configuration + + diff --git a/nuiton-config-maven-plugin/src/main/resources/config-report_en.properties b/nuiton-config-maven-plugin/src/main/resources/config-report_en.properties new file mode 100644 index 0000000..eb20e1d --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/resources/config-report_en.properties @@ -0,0 +1,21 @@ +### +# #%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% +### diff --git a/nuiton-config-maven-plugin/src/main/resources/config-report_fr.properties b/nuiton-config-maven-plugin/src/main/resources/config-report_fr.properties new file mode 100644 index 0000000..4d39419 --- /dev/null +++ b/nuiton-config-maven-plugin/src/main/resources/config-report_fr.properties @@ -0,0 +1,49 @@ +### +# #%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% +### +report.title=Configuration +report.description=Fournit des informations sur les configurations utilisables dans le projet. +report.overview.title=Pr\u00E9ambule +report.overview.text=Ce rapport d\u00E9crit les configurations utilisables dans ce projet. +report.detail.text.noConfig=Aucune configuration trouv\u00E9e dans le class-path. +report.config.option.key=Clef +report.noDefaultValue=Pas de valeur par d\u00E9faut +report.config.option.description=Description +report.config.option.type=Type +report.config.option.defaultValue=Valeur par d\u00E9faut +report.config.option.final=Option modifiable +report.config.option.transient=Option sauvegardable +report.config.name=Nom de la configuration +report.config.description=Description +report.config.nbOptions=Nombre d'options +report.config.nbActions=Nombre d'actions +report.config.option.detail=D\u00E9tails de l'option +report.back.options.table=Retour sur la table des options +report.overview.more.information=Pour plus d'informations sur ApplicationConfig +report.true=Oui +report.false=Non +report.detail.title=D\u00E9tail des configurations +report.detail.text=On d\u00E9taille ici une par une les configurations d\u00E9finies pour le projet +report.detail.configuration.title=Configuration +report.detail.options.title=Options de la configuration +report.detail.actions.title=Actions de la configuration +report.detail.options.noOptions=Aucune option d\u00E9finie pour cette configuration +report.detail.actions.noActions=Aucune action d\u00E9finie pour cette configuration -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.

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 9e511bd7646e75e2152dfca3bbf453fe6fd3256d Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Sep 30 15:23:27 2016 +0200 Add example module --- nuiton-config-example/LICENSE.txt | 165 +++++++++++++++++++++ nuiton-config-example/README.md | 0 nuiton-config-example/pom.xml | 95 ++++++++++++ .../src/license/THIRD-PARTY.properties | 17 +++ .../org/nuiton/config/example/MyApplication.java | 45 ++++++ .../config/example/MyApplicationConfigOption.java | 157 ++++++++++++++++++++ .../example/MyApplicationConfigProvider.java | 56 +++++++ .../org.nuiton.config.ApplicationConfigProvider | 1 + nuiton-config-example/src/site/apt/index.apt | 45 ++++++ nuiton-config-example/src/site/site_fr.xml | 47 ++++++ pom.xml | 10 +- 11 files changed, 630 insertions(+), 8 deletions(-) diff --git a/nuiton-config-example/LICENSE.txt b/nuiton-config-example/LICENSE.txt new file mode 100644 index 0000000..cca7fc2 --- /dev/null +++ b/nuiton-config-example/LICENSE.txt @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/nuiton-config-example/README.md b/nuiton-config-example/README.md new file mode 100644 index 0000000..e69de29 diff --git a/nuiton-config-example/pom.xml b/nuiton-config-example/pom.xml new file mode 100644 index 0000000..b26c4b3 --- /dev/null +++ b/nuiton-config-example/pom.xml @@ -0,0 +1,95 @@ +<?xml version="1.0" encoding="UTF-8"?> +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>org.nuiton</groupId> + <artifactId>nuiton-config-project</artifactId> + <version>3.0-SNAPSHOT</version> + </parent> + + <artifactId>nuiton-config-example</artifactId> + + <name>Nuiton Config :: Example</name> + <description>Nuiton Config Example</description> + <inceptionYear>2016</inceptionYear> + + <properties> + + <javaVersion>1.8</javaVersion> + <signatureArtifactId>java18</signatureArtifactId> + <signatureVersion>1.0</signatureVersion> + + <!-- Post Release configuration --> + <skipPostRelease>false</skipPostRelease> + + </properties> + + <dependencies> + + <dependency> + <groupId>${project.groupId}</groupId> + <artifactId>nuiton-config</artifactId> + <version>${project.version}</version> + </dependency> + + </dependencies> + + <build> + + <plugins> + + <plugin> + <groupId>${project.groupId}</groupId> + <artifactId>nuiton-config-maven-plugin</artifactId> + <version>${project.version}</version> + <executions> + <execution> + <phase>generate-sources</phase> + <id>generate-config</id> + <configuration> + <modelName>MyApplication</modelName> + </configuration> + <goals> + <goal>generate</goal> + </goals> + </execution> + </executions> + </plugin> + + </plugins> + + </build> + + <profiles> + + <profile> + <id>reporting</id> + <activation> + <property> + <name>performRelease</name> + <value>true</value> + </property> + </activation> + + <reporting> + <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> + </plugin> + </plugins> + </reporting> + + </profile> + + </profiles> +</project> diff --git a/nuiton-config-example/src/license/THIRD-PARTY.properties b/nuiton-config-example/src/license/THIRD-PARTY.properties new file mode 100644 index 0000000..357b66f --- /dev/null +++ b/nuiton-config-example/src/license/THIRD-PARTY.properties @@ -0,0 +1,17 @@ +# Generated by org.codehaus.mojo.license.AddThirdPartyMojo +#------------------------------------------------------------------------------- +# Already used licenses in project : +# - BSD License +# - COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0 +# - Indiana University Extreme! Lab Software License, vesion 1.1.1 +# - Lesser General Public License (LGPL) v 3.0 +# - Lesser General Public License (LPGL) +# - Lesser General Public License (LPGL) v 2.1 +# - MIT License +# - The Apache Software License, Version 2.0 +#------------------------------------------------------------------------------- +# Please fill the missing licenses for dependencies : +# +# +#Fri Sep 30 13:56:47 CEST 2016 +commons-primitives--commons-primitives--1.0=The Apache Software License, Version 2.0 diff --git a/nuiton-config-example/src/main/java/org/nuiton/config/example/MyApplication.java b/nuiton-config-example/src/main/java/org/nuiton/config/example/MyApplication.java new file mode 100644 index 0000000..ca3bcfc --- /dev/null +++ b/nuiton-config-example/src/main/java/org/nuiton/config/example/MyApplication.java @@ -0,0 +1,45 @@ +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.ArgumentsParserException; + +/** + * Created on 30/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class MyApplication { + + public static void main(String... args) throws ArgumentsParserException { + + MyApplicationConfig config = new MyApplicationConfig(); + 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()); + + } + +} diff --git a/nuiton-config-example/src/main/java/org/nuiton/config/example/MyApplicationConfigOption.java b/nuiton-config-example/src/main/java/org/nuiton/config/example/MyApplicationConfigOption.java new file mode 100644 index 0000000..f69f9b2 --- /dev/null +++ b/nuiton-config-example/src/main/java/org/nuiton/config/example/MyApplicationConfigOption.java @@ -0,0 +1,157 @@ +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.ApplicationConfig; +import org.nuiton.config.ConfigOptionDef; + +import java.io.File; + +public enum MyApplicationConfigOption implements ConfigOptionDef { + + /** + * le nom du fichier de configuration (sans le prefix .) + */ + CONFIG_FILE( + String.class, + ApplicationConfig.CONFIG_FILE_NAME, + "Nom du fichier de configuration", + "application", + true, + true + ), + + /** + * le repertoire ou est stoquee la base locale + */ + DATA_DIRECTORY( + File.class, + "data.directory", + "Répertoire de données", + "${user.home}/.application", + true, + true + ), + + /** + * le repertoire ou est stoquee la base locale + */ + DB_DIRECTORY( + File.class, + "db.directory", + "Répertoire de la base de données", + "${data.directory}/db", + true, + true + ); + + /** + * Clef qui represente 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; + + MyApplicationConfigOption(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/java/org/nuiton/config/example/MyApplicationConfigProvider.java b/nuiton-config-example/src/main/java/org/nuiton/config/example/MyApplicationConfigProvider.java new file mode 100644 index 0000000..dc08a02 --- /dev/null +++ b/nuiton-config-example/src/main/java/org/nuiton/config/example/MyApplicationConfigProvider.java @@ -0,0 +1,56 @@ +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.ApplicationConfigProvider; +import org.nuiton.config.ConfigActionDef; + +import java.util.Locale; + +/** + * Created on 30/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class MyApplicationConfigProvider implements ApplicationConfigProvider { + + @Override + public String getName() { + return "application"; + } + + @Override + public String getDescription(Locale locale) { + return "Configuration"; + } + + @Override + public MyApplicationConfigOption[] getOptions() { + return MyApplicationConfigOption.values(); + } + + @Override + public ConfigActionDef[] getActions() { + return new ConfigActionDef[0]; + } +} diff --git a/nuiton-config-example/src/main/resources/META-INF/services/org.nuiton.config.ApplicationConfigProvider b/nuiton-config-example/src/main/resources/META-INF/services/org.nuiton.config.ApplicationConfigProvider new file mode 100644 index 0000000..499f119 --- /dev/null +++ b/nuiton-config-example/src/main/resources/META-INF/services/org.nuiton.config.ApplicationConfigProvider @@ -0,0 +1 @@ +org.nuiton.config.example.MyApplicationConfigProvider \ No newline at end of file diff --git a/nuiton-config-example/src/site/apt/index.apt b/nuiton-config-example/src/site/apt/index.apt new file mode 100644 index 0000000..d29c8c0 --- /dev/null +++ b/nuiton-config-example/src/site/apt/index.apt @@ -0,0 +1,45 @@ +~~~ +~~ #%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/site_fr.xml b/nuiton-config-example/src/site/site_fr.xml new file mode 100644 index 0000000..30815f3 --- /dev/null +++ b/nuiton-config-example/src/site/site_fr.xml @@ -0,0 +1,47 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + #%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% + --> + + +<project name="${project.name}" xmlns="http://maven.apache.org/DECORATION/1.4.0" + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/DECORATION/1.4.0 http://maven.apache.org/xsd/decoration-1.4.0.xsd"> + + <bannerLeft> + <name>${project.name}</name> + <href>index.html</href> + </bannerLeft> + + <body> + + <breadcrumbs> + <item name="${project.name}" href="./index.html"/> + </breadcrumbs> + + <menu ref="parent"/> + <menu name="Utilisateur"> + <item name="Accueil" href="index.html"/> + </menu> + <menu ref="reports"/> + + </body> +</project> diff --git a/pom.xml b/pom.xml index 396878f..5aba643 100644 --- a/pom.xml +++ b/pom.xml @@ -15,7 +15,7 @@ <name>Nuiton Config</name> <description>Simple Application config</description> <url>http://nuiton-config.nuiton.org</url> - <inceptionYear>2013</inceptionYear> + <inceptionYear>2016</inceptionYear> <developers> @@ -48,6 +48,7 @@ <modules> <module>nuiton-config</module> <module>nuiton-config-maven-plugin</module> + <module>nuiton-config-example</module> </modules> <scm> @@ -291,13 +292,6 @@ <version>${doxiaVersion}</version> </dependency> - <dependency> - <groupId>xml-apis</groupId> - <artifactId>xml-apis</artifactId> - <version>2.0.2</version> - <scope>provided</scope> - </dependency> - </dependencies> </dependencyManagement> -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.