branch develop updated (d83681b -> 46449db)
This is an automated email from the git hooks/post-receive script. New change to branch develop in repository eugene. See https://gitlab.nuiton.org/nuiton/eugene.git from d83681b [jgitflow-maven-plugin]Updating develop poms back to pre merge state new 582dd02 Add method to convert constant name to identifier name (Fixes #4035) new 46449db Add a new mojo to generate application config (Fixes #4036) The 2 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Detailed log of new commits: commit 46449dbe3a35761c700d67412f0e383ddf843fbc Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Sep 15 14:52:43 2016 +0200 Add a new mojo to generate application config (Fixes #4036) commit 582dd022aa6b6be46fcb300c8a3d1492a92c815e Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Sep 15 14:49:55 2016 +0200 Add method to convert constant name to identifier name (Fixes #4035) Summary of changes: {eugene => eugene-config-templates}/LICENSE.txt | 0 .../README.md | 0 .../pom.xml | 30 +- .../src/license/THIRD-PARTY.properties | 0 .../templates/ApplicationConfigTransformer.java | 255 + .../src/site/fr/rst/index.rst | 6 +- .../src/site}/rst/index.rst | 6 +- .../src/site/site_en.xml | 0 .../src/site/site_fr.xml | 0 eugene-maven-plugin/pom.xml | 21 + .../plugin/GenerateApplicationConfigMojo.java | 392 + .../plugin/parser/java/Java8BaseVisitor.java | 1699 ++ .../eugene/plugin/parser/java/Java8Lexer.java | 601 + .../eugene/plugin/parser/java/Java8Parser.java | 18030 +++++++++++++++++++ .../eugene/plugin/parser/java/Java8Visitor.java | 1461 ++ .../main/java/org/nuiton/eugene/GeneratorUtil.java | 27 + pom.xml | 21 + 17 files changed, 22540 insertions(+), 9 deletions(-) copy {eugene => eugene-config-templates}/LICENSE.txt (100%) copy {eugene-yaml-templates => eugene-config-templates}/README.md (100%) copy {eugene-yaml-templates => eugene-config-templates}/pom.xml (69%) copy {eugene-yaml-templates => eugene-config-templates}/src/license/THIRD-PARTY.properties (100%) create mode 100644 eugene-config-templates/src/main/java/org/nuiton/eugene/config/templates/ApplicationConfigTransformer.java copy {eugene-yaml-templates => eugene-config-templates}/src/site/fr/rst/index.rst (92%) copy {eugene-yaml-templates/src/site/fr => eugene-config-templates/src/site}/rst/index.rst (92%) copy {eugene-yaml-templates => eugene-config-templates}/src/site/site_en.xml (100%) copy {eugene-yaml-templates => eugene-config-templates}/src/site/site_fr.xml (100%) create mode 100644 eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/GenerateApplicationConfigMojo.java create mode 100644 eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8BaseVisitor.java create mode 100644 eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Lexer.java create mode 100644 eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Parser.java create mode 100644 eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Visitor.java -- 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 eugene. See https://gitlab.nuiton.org/nuiton/eugene.git commit 582dd022aa6b6be46fcb300c8a3d1492a92c815e Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Sep 15 14:49:55 2016 +0200 Add method to convert constant name to identifier name (Fixes #4035) --- .../main/java/org/nuiton/eugene/GeneratorUtil.java | 27 ++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java b/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java index 28293a3..06c58cb 100644 --- a/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java +++ b/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java @@ -782,6 +782,33 @@ public class GeneratorUtil { } /** + * Convertit un nom de constante en nom de variable. + * + * @param constantName le nom de constante a convertir + * @return le nom de la variable à partir du nom de la constante + * @since 3.0 + */ + public static String convertConstantNameToVariableName(String constantName) { + StringBuilder buffer = new StringBuilder(); + boolean lastCarIsUp = false; + for (int i = 0, j = constantName.length(); i < j; i++) { + char c = constantName.charAt(i); + if ('_' == c) { + lastCarIsUp = true; + continue; + } + if (lastCarIsUp) { + c = Character.toUpperCase(c); + lastCarIsUp = false; + } else { + c = Character.toLowerCase(c); + } + buffer.append(c); + } + return buffer.toString(); + } + + /** * Renvoie le nom de l'attribut de classe d'association en fonction des cas: * Si l'attribut porte le même nom que le type (extrémité inverse de * l'association), on lui ajoute le nom de la classe d'association -- 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 eugene. See https://gitlab.nuiton.org/nuiton/eugene.git commit 46449dbe3a35761c700d67412f0e383ddf843fbc Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Sep 15 14:52:43 2016 +0200 Add a new mojo to generate application config (Fixes #4036) --- eugene-config-templates/LICENSE.txt | 165 + eugene-config-templates/README.md | 0 eugene-config-templates/pom.xml | 91 + .../src/license/THIRD-PARTY.properties | 21 + .../templates/ApplicationConfigTransformer.java | 255 + eugene-config-templates/src/site/fr/rst/index.rst | 33 + eugene-config-templates/src/site/rst/index.rst | 33 + eugene-config-templates/src/site/site_en.xml | 54 + eugene-config-templates/src/site/site_fr.xml | 58 + eugene-maven-plugin/pom.xml | 21 + .../plugin/GenerateApplicationConfigMojo.java | 392 + .../plugin/parser/java/Java8BaseVisitor.java | 1699 ++ .../eugene/plugin/parser/java/Java8Lexer.java | 601 + .../eugene/plugin/parser/java/Java8Parser.java | 18030 +++++++++++++++++++ .../eugene/plugin/parser/java/Java8Visitor.java | 1461 ++ pom.xml | 21 + 16 files changed, 22935 insertions(+) diff --git a/eugene-config-templates/LICENSE.txt b/eugene-config-templates/LICENSE.txt new file mode 100644 index 0000000..cca7fc2 --- /dev/null +++ b/eugene-config-templates/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/eugene-config-templates/README.md b/eugene-config-templates/README.md new file mode 100644 index 0000000..e69de29 diff --git a/eugene-config-templates/pom.xml b/eugene-config-templates/pom.xml new file mode 100644 index 0000000..5df3511 --- /dev/null +++ b/eugene-config-templates/pom.xml @@ -0,0 +1,91 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + #%L + EUGene :: EUGene + + $HeadURL$ + %% + Copyright (C) 2004 - 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>eugene</artifactId> + <version>3.0-SNAPSHOT</version> + </parent> + + <groupId>org.nuiton.eugene</groupId> + <artifactId>eugene-config-templates</artifactId> + + <name>EUGene :: Config templates</name> + <inceptionYear>2016</inceptionYear> + + <dependencies> + + <dependency> + <groupId>${project.groupId}</groupId> + <artifactId>eugene</artifactId> + <version>${project.version}</version> + </dependency> + + <dependency> + <groupId>org.nuiton</groupId> + <artifactId>nuiton-config</artifactId> + </dependency> + + </dependencies> + + <build> + <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> + + <!-- expose new plexus components --> + <plugin> + <groupId>org.codehaus.plexus</groupId> + <artifactId>plexus-component-metadata</artifactId> + <executions> + <execution> + <goals> + <goal>generate-metadata</goal> + </goals> + </execution> + </executions> + </plugin> + </plugins> + </build> + +</project> diff --git a/eugene-config-templates/src/license/THIRD-PARTY.properties b/eugene-config-templates/src/license/THIRD-PARTY.properties new file mode 100644 index 0000000..91e981a --- /dev/null +++ b/eugene-config-templates/src/license/THIRD-PARTY.properties @@ -0,0 +1,21 @@ +# 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 +# - Mozilla Public License Version 1.0 +# - The Apache Software License, Version 2.0 +# - The SAX License +# - The W3C License +# - http://jaxen.codehaus.org/license.html +#------------------------------------------------------------------------------- +# Please fill the missing licenses for dependencies : +# +# +#Tue Jul 23 16:39:16 CEST 2013 +commons-primitives--commons-primitives--1.0=The Apache Software License, Version 2.0 diff --git a/eugene-config-templates/src/main/java/org/nuiton/eugene/config/templates/ApplicationConfigTransformer.java b/eugene-config-templates/src/main/java/org/nuiton/eugene/config/templates/ApplicationConfigTransformer.java new file mode 100644 index 0000000..4604f20 --- /dev/null +++ b/eugene-config-templates/src/main/java/org/nuiton/eugene/config/templates/ApplicationConfigTransformer.java @@ -0,0 +1,255 @@ +package org.nuiton.eugene.config.templates; + +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. + * Created on 15/09/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @plexus.component role="org.nuiton.eugene.Template" role-hint="org.nuiton.eugene.config.templates.ApplicationConfigTransformer" + * @since 3.0 + */ +public class ApplicationConfigTransformer extends ObjectModelTransformerToJava { + + private static final Log log = LogFactory.getLog(ApplicationConfigTransformer.class); + + @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); + } + + } + } + + protected void generateAbstractClass(String packageName, String abstractClassName, ObjectModelClass input) { + + String optionClassName = getProperty("optionClassName"); + + ObjectModelClass output = createAbstractClass(abstractClassName, packageName); + + addImport(output, optionClassName); + + if (log.isInfoEnabled()) { + log.info("Generate " + output.getQualifiedName()); + } + addAttribute(output, "delegate", ApplicationConfig.class, "", ObjectModelJavaModifier.PRIVATE); + + ObjectModelOperation constructor = addConstructor(output, ObjectModelJavaModifier.PROTECTED); + setOperationBody(constructor, "" + /*{ + this.delegate = new ApplicationConfig(); + }*/ + ); + + ObjectModelOperation getDelegate = addOperation(output, "getDelegate", ApplicationConfig.class, ObjectModelJavaModifier.PROTECTED); + setOperationBody(getDelegate, "" + /*{ + return delegate; + }*/ + ); + + 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 + ); + + } + + } + + protected void generateClass(String packageName, String className, String abstractClassName) { + + ObjectModelClass output = createClass(className, packageName); + if (log.isInfoEnabled()) { + log.info("Generate " + output.getQualifiedName()); + } + setSuperClass(output, abstractClassName); + + } + + protected 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"); + + protected 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%>) delegate.<%=methodName%>(<%=simpleType%>.class, <%=constantName%>.getKey()); + }*/ + ); + } else + + { + setOperationBody(operation, "" + /*{ + return delegate.<%=methodName%>(<%=constantName%>.getKey()); + }*/ + ); + + if ("Boolean".equals(simpleType)) { + operation = addOperation( + output, + getJavaBeanMethodName(JavaGeneratorUtil.OPERATION_GETTER_BOOLEAN_PREFIX, attrName), + "boolean", + ObjectModelJavaModifier.PUBLIC + ); + + setOperationBody(operation, "" + /*{ + return delegate.<%=methodName%>(<%=constantName%>.getKey()); + }*/ + ); + } + } + } + + protected 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, "" + /*{ + delegate.setOption(<%=constantName%>.getKey(), String.valueOf(<%=attrName%>)); + }*/ + ); + + if ("Boolean".equals(simpleType)) { + operation = addOperation( + output, + getJavaBeanMethodName("set", attrName), + "void", + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, "boolean", attrName); + + setOperationBody(operation, "" + /*{ + delegate.setOption(<%=constantName%>.getKey(), String.valueOf(<%=attrName%>)); + }*/ + ); + } + + + } + +} diff --git a/eugene-config-templates/src/site/fr/rst/index.rst b/eugene-config-templates/src/site/fr/rst/index.rst new file mode 100644 index 0000000..7777c47 --- /dev/null +++ b/eugene-config-templates/src/site/fr/rst/index.rst @@ -0,0 +1,33 @@ +.. - +.. * #%L +.. * EUGene :: YAML templates +.. * %% +.. * Copyright (C) 2013 - 2014 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% +.. - + +======================= +EUGene Config templates +======================= + +.. contents:: + +Introduction +------------ + +Example +------- diff --git a/eugene-config-templates/src/site/rst/index.rst b/eugene-config-templates/src/site/rst/index.rst new file mode 100644 index 0000000..7777c47 --- /dev/null +++ b/eugene-config-templates/src/site/rst/index.rst @@ -0,0 +1,33 @@ +.. - +.. * #%L +.. * EUGene :: YAML templates +.. * %% +.. * Copyright (C) 2013 - 2014 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% +.. - + +======================= +EUGene Config templates +======================= + +.. contents:: + +Introduction +------------ + +Example +------- diff --git a/eugene-config-templates/src/site/site_en.xml b/eugene-config-templates/src/site/site_en.xml new file mode 100644 index 0000000..d403320 --- /dev/null +++ b/eugene-config-templates/src/site/site_en.xml @@ -0,0 +1,54 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + #%L + EUGene :: YAML templates + %% + Copyright (C) 2013 - 2014 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 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> + + <links> + <item name="[fr" href="fr/index.html"/> + <item name="en]" href="index.html"/> + </links> + + <breadcrumbs> + <item name="${project.name}" href="./index.html"/> + </breadcrumbs> + + <menu ref="parent"/> + + <menu name="User"> + <item href="index.html" name="Home"/> + </menu> + + <menu ref="reports"/> + + </body> +</project> diff --git a/eugene-config-templates/src/site/site_fr.xml b/eugene-config-templates/src/site/site_fr.xml new file mode 100644 index 0000000..7808bd2 --- /dev/null +++ b/eugene-config-templates/src/site/site_fr.xml @@ -0,0 +1,58 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + #%L + EUGene :: YAML templates + %% + Copyright (C) 2013 - 2014 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 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> + + <links> + <item name="[fr" href="index.html"/> + <item name="en]" href="../index.html"/> + </links> + + <breadcrumbs> + <item name="${project.name}" href="./index.html"/> + </breadcrumbs> + + <!-- TC-20100117 : ne fonctionne pas sur une langue non principale --> + <!--<menu ref="parent"/>--> + <menu name="Parent Projet"> + <item name="Eugene" href="../../fr/index.html"/> + </menu> + + <menu name="Utilisateur"> + <item href="index.html" name="Accueil"/> + </menu> + + <menu ref="reports"/> + + </body> +</project> diff --git a/eugene-maven-plugin/pom.xml b/eugene-maven-plugin/pom.xml index 24e88df..d35842d 100644 --- a/eugene-maven-plugin/pom.xml +++ b/eugene-maven-plugin/pom.xml @@ -78,9 +78,30 @@ </dependency> <dependency> + <groupId>${project.groupId}</groupId> + <artifactId>eugene-config-templates</artifactId> + <version>${project.version}</version> + <scope>compile</scope> + </dependency> + + <dependency> + <groupId>com.tunnelvisionlabs</groupId> + <artifactId>antlr4-runtime</artifactId> + </dependency> + <dependency> + <groupId>com.tunnelvisionlabs</groupId> + <artifactId>antlr4-annotations</artifactId> + </dependency> + + <dependency> <groupId>org.nuiton</groupId> <artifactId>nuiton-utils</artifactId> </dependency> + <dependency> + <groupId>org.nuiton</groupId> + <artifactId>nuiton-config</artifactId> + </dependency> + <dependency> <groupId>org.apache.commons</groupId> diff --git a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/GenerateApplicationConfigMojo.java b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/GenerateApplicationConfigMojo.java new file mode 100644 index 0000000..cc1edf7 --- /dev/null +++ b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/GenerateApplicationConfigMojo.java @@ -0,0 +1,392 @@ +package org.nuiton.eugene.plugin; + +/* + * #%L + * I18n :: Maven Plugin + * %% + * Copyright (C) 2007 - 2016 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% + */ + +import org.antlr.v4.runtime.ANTLRInputStream; +import org.antlr.v4.runtime.CommonTokenStream; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.misc.NotNull; +import org.apache.commons.io.FileUtils; +import org.apache.commons.lang.StringUtils; +import org.apache.maven.plugin.MojoExecutionException; +import org.apache.maven.plugins.annotations.Component; +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.eugene.DefaultTemplateConfiguration; +import org.nuiton.eugene.Template; +import org.nuiton.eugene.config.templates.ApplicationConfigTransformer; +import org.nuiton.eugene.java.JavaGeneratorUtil; +import org.nuiton.eugene.models.Model; +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.eugene.plugin.parser.java.Java8BaseVisitor; +import org.nuiton.eugene.plugin.parser.java.Java8Lexer; +import org.nuiton.eugene.plugin.parser.java.Java8Parser; +import org.nuiton.plugin.AbstractPlugin; +import org.nuiton.plugin.PluginHelper; +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 a i18n enum class helper. + * + * Created on 28/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.6 + */ +@Mojo(name = "generate-config", defaultPhase = LifecyclePhase.GENERATE_SOURCES, requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME) +public class GenerateApplicationConfigMojo extends AbstractPlugin { + + /** + * To set the package fully qualified name of the generated class. + * + * By default, will use groupId.artifactId (with {@code -} replaced by {@code .}) plus {@code .config}. + */ + @Parameter(property = "i18n.packageName") + private String packageName; + + /** + * Model name (will prefix the generated files names with it). + */ + @Parameter(property = "i18n.modelName", required = true) + private String modelName; + + /** + * The fully qualified name of the enum class of options to scan to generate the configuration java files. + * + * By default, will use groupId.artifactId (with {@code -} replaced by {@code .}) plus {@code .config.modelNameOption}. + */ + @Parameter(property = "i18n.inputClassName") + private String inputClassName; + + /** + * The source directory where to scan options java file. + */ + @Parameter(property = "i18n.sourceDirectory", defaultValue = "${basedir}/src/main/java", required = true) + private File sourceDirectory; + + /** + * The root directory where to generated. + */ + @Parameter(property = "i18n.outputdirectory", defaultValue = "${basedir}/target/generated-sources/java", required = true) + private File outputdirectory; + + /** + * Pour activer le mode verbeux. + * + * @since 2.0.0 + */ + @Parameter(property = "eugene.verbose", defaultValue = "${maven.verbose}") + protected boolean verbose; + + /** + * Encoding to be used for generation of files. + * + * <b>Note:</b> If nothing is filled here, we will use the system + * property {@code file.encoding}. + * + * @since 2.0.0 + */ + @Parameter(property = "eugene.encoding", defaultValue = "${project.build.sourceEncoding}") + protected String encoding; + + /** + * Encoding to be used for generation of files. + * + * <b>Note:</b> If nothing is filled here, we will use the system + * property {@code file.encoding}. + * + * @since 2.0.0 + */ + @Parameter(property = "eugene.prefix", defaultValue = "Config") + protected String prefix; + + /** + * Maven project. + * + * @since 2.0.0 + */ + @Parameter(defaultValue = "${project}", readonly = true) + protected MavenProject project; + + /** All available templates introspects via plexus. */ + @Component(role = Template.class) + protected Map<String, Template<?>> modelTemplates; + + private ObjectModelImpl model; + + protected Template<Model> template; + + @Override + protected void init() throws Exception { + + if (packageName == null) { + + packageName = getProject().getGroupId() + "." + getProject().getArtifactId().replaceAll("-", "."); + getLog().info("Use package name: " + packageName); + } + + if (inputClassName == null) { + + inputClassName = packageName + "." + modelName + prefix + "Option"; + + File file = PluginHelper.getFile(sourceDirectory, inputClassName.split("\\.")); + File javaFile = new File(file.getParentFile(), file.getName() + ".java"); + + if (!javaFile.exists()) { + + prefix = "Configuration"; + + inputClassName = packageName + "." + modelName + prefix + "Option"; + + file = PluginHelper.getFile(sourceDirectory, inputClassName.split("\\.")); + javaFile = new File(file.getParentFile(), file.getName() + ".java"); + + if (!javaFile.exists()) { + throw new MojoExecutionException("Can't find option file at: " + javaFile); + } + } + getLog().info("Will scan options from: " + inputClassName); + + } + + ClassLoader loader = this.initClassLoader(getProject(), sourceDirectory, true, false, false, true, true); + + // get options + + model = new ObjectModelImpl(); + model.setName(modelName); + + getLog().info("Model name: " + model.getName()); + + String className = modelName + prefix; + + File file = PluginHelper.getFile(sourceDirectory, inputClassName.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("optionClassName", inputClassName); + + template = (Template<Model>) modelTemplates.get(ApplicationConfigTransformer.class.getName()); + 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; + } + + public String getEncoding() { + return encoding; + } + + public void setEncoding(String encoding) { + this.encoding = encoding; + } + + @Override + public void setProject(MavenProject project) { + this.project = project; + } + + protected class JavaParserVisitor extends Java8BaseVisitor<Void> { + + protected final Map<String, String> names; + + private final ClassLoader loader; + protected final File file; + + private JavaParserVisitor(ClassLoader loader, File file) { + this.loader = loader; + this.file = file; + names = new LinkedHashMap<>(); + } + + public 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(@NotNull 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/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8BaseVisitor.java b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8BaseVisitor.java new file mode 100644 index 0000000..8b2eeee --- /dev/null +++ b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8BaseVisitor.java @@ -0,0 +1,1699 @@ +// Generated from Java8.g4 by ANTLR 4.5 +package org.nuiton.eugene.plugin.parser.java; + +/* + * #%L + * I18n :: Maven Plugin + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2016 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% + */ + +import org.antlr.v4.runtime.misc.NotNull; +import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +/** + * This class provides an empty implementation of {@link Java8Visitor}, + * which can be extended to create a visitor which only needs to handle a subset + * of the available methods. + * + * @param <Result> The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +public class Java8BaseVisitor<Result> extends AbstractParseTreeVisitor<Result> implements Java8Visitor<Result> { + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitLiteral(@NotNull Java8Parser.LiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitType(@NotNull Java8Parser.TypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPrimitiveType(@NotNull Java8Parser.PrimitiveTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitNumericType(@NotNull Java8Parser.NumericTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitIntegralType(@NotNull Java8Parser.IntegralTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitFloatingPointType(@NotNull Java8Parser.FloatingPointTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitReferenceType(@NotNull Java8Parser.ReferenceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassOrInterfaceType(@NotNull Java8Parser.ClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassType(@NotNull Java8Parser.ClassTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassType_lf_classOrInterfaceType(@NotNull Java8Parser.ClassType_lf_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassType_lfno_classOrInterfaceType(@NotNull Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInterfaceType(@NotNull Java8Parser.InterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInterfaceType_lf_classOrInterfaceType(@NotNull Java8Parser.InterfaceType_lf_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInterfaceType_lfno_classOrInterfaceType(@NotNull Java8Parser.InterfaceType_lfno_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeVariable(@NotNull Java8Parser.TypeVariableContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitArrayType(@NotNull Java8Parser.ArrayTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitDims(@NotNull Java8Parser.DimsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeParameter(@NotNull Java8Parser.TypeParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeParameterModifier(@NotNull Java8Parser.TypeParameterModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeBound(@NotNull Java8Parser.TypeBoundContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAdditionalBound(@NotNull Java8Parser.AdditionalBoundContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeArguments(@NotNull Java8Parser.TypeArgumentsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeArgumentList(@NotNull Java8Parser.TypeArgumentListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeArgument(@NotNull Java8Parser.TypeArgumentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitWildcard(@NotNull Java8Parser.WildcardContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitWildcardBounds(@NotNull Java8Parser.WildcardBoundsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPackageName(@NotNull Java8Parser.PackageNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeName(@NotNull Java8Parser.TypeNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPackageOrTypeName(@NotNull Java8Parser.PackageOrTypeNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitExpressionName(@NotNull Java8Parser.ExpressionNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodName(@NotNull Java8Parser.MethodNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAmbiguousName(@NotNull Java8Parser.AmbiguousNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitCompilationUnit(@NotNull Java8Parser.CompilationUnitContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPackageDeclaration(@NotNull Java8Parser.PackageDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPackageModifier(@NotNull Java8Parser.PackageModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitImportDeclaration(@NotNull Java8Parser.ImportDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSingleTypeImportDeclaration(@NotNull Java8Parser.SingleTypeImportDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeImportOnDemandDeclaration(@NotNull Java8Parser.TypeImportOnDemandDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSingleStaticImportDeclaration(@NotNull Java8Parser.SingleStaticImportDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitStaticImportOnDemandDeclaration(@NotNull Java8Parser.StaticImportOnDemandDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeDeclaration(@NotNull Java8Parser.TypeDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassDeclaration(@NotNull Java8Parser.ClassDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitNormalClassDeclaration(@NotNull Java8Parser.NormalClassDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassModifier(@NotNull Java8Parser.ClassModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeParameters(@NotNull Java8Parser.TypeParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeParameterList(@NotNull Java8Parser.TypeParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSuperclass(@NotNull Java8Parser.SuperclassContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSuperinterfaces(@NotNull Java8Parser.SuperinterfacesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInterfaceTypeList(@NotNull Java8Parser.InterfaceTypeListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassBody(@NotNull Java8Parser.ClassBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassBodyDeclaration(@NotNull Java8Parser.ClassBodyDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassMemberDeclaration(@NotNull Java8Parser.ClassMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitFieldDeclaration(@NotNull Java8Parser.FieldDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitFieldModifier(@NotNull Java8Parser.FieldModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitVariableDeclaratorList(@NotNull Java8Parser.VariableDeclaratorListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitVariableDeclarator(@NotNull Java8Parser.VariableDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitVariableDeclaratorId(@NotNull Java8Parser.VariableDeclaratorIdContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitVariableInitializer(@NotNull Java8Parser.VariableInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannType(@NotNull Java8Parser.UnannTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannPrimitiveType(@NotNull Java8Parser.UnannPrimitiveTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannReferenceType(@NotNull Java8Parser.UnannReferenceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannClassOrInterfaceType(@NotNull Java8Parser.UnannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannClassType(@NotNull Java8Parser.UnannClassTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannClassType_lf_unannClassOrInterfaceType(@NotNull Java8Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannClassType_lfno_unannClassOrInterfaceType(@NotNull Java8Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannInterfaceType(@NotNull Java8Parser.UnannInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannInterfaceType_lf_unannClassOrInterfaceType(@NotNull Java8Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannInterfaceType_lfno_unannClassOrInterfaceType(@NotNull Java8Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannTypeVariable(@NotNull Java8Parser.UnannTypeVariableContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnannArrayType(@NotNull Java8Parser.UnannArrayTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodDeclaration(@NotNull Java8Parser.MethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodModifier(@NotNull Java8Parser.MethodModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodHeader(@NotNull Java8Parser.MethodHeaderContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitResult(@NotNull Java8Parser.ResultContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodDeclarator(@NotNull Java8Parser.MethodDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitFormalParameterList(@NotNull Java8Parser.FormalParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitFormalParameters(@NotNull Java8Parser.FormalParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitFormalParameter(@NotNull Java8Parser.FormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitVariableModifier(@NotNull Java8Parser.VariableModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitLastFormalParameter(@NotNull Java8Parser.LastFormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitReceiverParameter(@NotNull Java8Parser.ReceiverParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitThrows_(@NotNull Java8Parser.Throws_Context ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitExceptionTypeList(@NotNull Java8Parser.ExceptionTypeListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitExceptionType(@NotNull Java8Parser.ExceptionTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodBody(@NotNull Java8Parser.MethodBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInstanceInitializer(@NotNull Java8Parser.InstanceInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitStaticInitializer(@NotNull Java8Parser.StaticInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitConstructorDeclaration(@NotNull Java8Parser.ConstructorDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitConstructorModifier(@NotNull Java8Parser.ConstructorModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitConstructorDeclarator(@NotNull Java8Parser.ConstructorDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSimpleTypeName(@NotNull Java8Parser.SimpleTypeNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitConstructorBody(@NotNull Java8Parser.ConstructorBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitExplicitConstructorInvocation(@NotNull Java8Parser.ExplicitConstructorInvocationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitEnumDeclaration(@NotNull Java8Parser.EnumDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitEnumBody(@NotNull Java8Parser.EnumBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitEnumConstantList(@NotNull Java8Parser.EnumConstantListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitEnumConstant(@NotNull Java8Parser.EnumConstantContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitEnumConstantModifier(@NotNull Java8Parser.EnumConstantModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitEnumBodyDeclarations(@NotNull Java8Parser.EnumBodyDeclarationsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInterfaceDeclaration(@NotNull Java8Parser.InterfaceDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitNormalInterfaceDeclaration(@NotNull Java8Parser.NormalInterfaceDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInterfaceModifier(@NotNull Java8Parser.InterfaceModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitExtendsInterfaces(@NotNull Java8Parser.ExtendsInterfacesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInterfaceBody(@NotNull Java8Parser.InterfaceBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInterfaceMemberDeclaration(@NotNull Java8Parser.InterfaceMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitConstantDeclaration(@NotNull Java8Parser.ConstantDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitConstantModifier(@NotNull Java8Parser.ConstantModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInterfaceMethodDeclaration(@NotNull Java8Parser.InterfaceMethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInterfaceMethodModifier(@NotNull Java8Parser.InterfaceMethodModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAnnotationTypeDeclaration(@NotNull Java8Parser.AnnotationTypeDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAnnotationTypeBody(@NotNull Java8Parser.AnnotationTypeBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAnnotationTypeMemberDeclaration(@NotNull Java8Parser.AnnotationTypeMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAnnotationTypeElementDeclaration(@NotNull Java8Parser.AnnotationTypeElementDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAnnotationTypeElementModifier(@NotNull Java8Parser.AnnotationTypeElementModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitDefaultValue(@NotNull Java8Parser.DefaultValueContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAnnotation(@NotNull Java8Parser.AnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitNormalAnnotation(@NotNull Java8Parser.NormalAnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitElementValuePairList(@NotNull Java8Parser.ElementValuePairListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitElementValuePair(@NotNull Java8Parser.ElementValuePairContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitElementValue(@NotNull Java8Parser.ElementValueContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitElementValueArrayInitializer(@NotNull Java8Parser.ElementValueArrayInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitElementValueList(@NotNull Java8Parser.ElementValueListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMarkerAnnotation(@NotNull Java8Parser.MarkerAnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSingleElementAnnotation(@NotNull Java8Parser.SingleElementAnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitArrayInitializer(@NotNull Java8Parser.ArrayInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitVariableInitializerList(@NotNull Java8Parser.VariableInitializerListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitBlock(@NotNull Java8Parser.BlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitBlockStatements(@NotNull Java8Parser.BlockStatementsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitBlockStatement(@NotNull Java8Parser.BlockStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitLocalVariableDeclarationStatement(@NotNull Java8Parser.LocalVariableDeclarationStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitLocalVariableDeclaration(@NotNull Java8Parser.LocalVariableDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitStatement(@NotNull Java8Parser.StatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitStatementNoShortIf(@NotNull Java8Parser.StatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitStatementWithoutTrailingSubstatement(@NotNull Java8Parser.StatementWithoutTrailingSubstatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitEmptyStatement(@NotNull Java8Parser.EmptyStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitLabeledStatement(@NotNull Java8Parser.LabeledStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitLabeledStatementNoShortIf(@NotNull Java8Parser.LabeledStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitExpressionStatement(@NotNull Java8Parser.ExpressionStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitStatementExpression(@NotNull Java8Parser.StatementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitIfThenStatement(@NotNull Java8Parser.IfThenStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitIfThenElseStatement(@NotNull Java8Parser.IfThenElseStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitIfThenElseStatementNoShortIf(@NotNull Java8Parser.IfThenElseStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAssertStatement(@NotNull Java8Parser.AssertStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSwitchStatement(@NotNull Java8Parser.SwitchStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSwitchBlock(@NotNull Java8Parser.SwitchBlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSwitchBlockStatementGroup(@NotNull Java8Parser.SwitchBlockStatementGroupContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSwitchLabels(@NotNull Java8Parser.SwitchLabelsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSwitchLabel(@NotNull Java8Parser.SwitchLabelContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitEnumConstantName(@NotNull Java8Parser.EnumConstantNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitWhileStatement(@NotNull Java8Parser.WhileStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitWhileStatementNoShortIf(@NotNull Java8Parser.WhileStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitDoStatement(@NotNull Java8Parser.DoStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitForStatement(@NotNull Java8Parser.ForStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitForStatementNoShortIf(@NotNull Java8Parser.ForStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitBasicForStatement(@NotNull Java8Parser.BasicForStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitBasicForStatementNoShortIf(@NotNull Java8Parser.BasicForStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitForInit(@NotNull Java8Parser.ForInitContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitForUpdate(@NotNull Java8Parser.ForUpdateContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitStatementExpressionList(@NotNull Java8Parser.StatementExpressionListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitEnhancedForStatement(@NotNull Java8Parser.EnhancedForStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitEnhancedForStatementNoShortIf(@NotNull Java8Parser.EnhancedForStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitBreakStatement(@NotNull Java8Parser.BreakStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitContinueStatement(@NotNull Java8Parser.ContinueStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitReturnStatement(@NotNull Java8Parser.ReturnStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitThrowStatement(@NotNull Java8Parser.ThrowStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitSynchronizedStatement(@NotNull Java8Parser.SynchronizedStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTryStatement(@NotNull Java8Parser.TryStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitCatches(@NotNull Java8Parser.CatchesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitCatchClause(@NotNull Java8Parser.CatchClauseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitCatchFormalParameter(@NotNull Java8Parser.CatchFormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitCatchType(@NotNull Java8Parser.CatchTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitFinally_(@NotNull Java8Parser.Finally_Context ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTryWithResourcesStatement(@NotNull Java8Parser.TryWithResourcesStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitResourceSpecification(@NotNull Java8Parser.ResourceSpecificationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitResourceList(@NotNull Java8Parser.ResourceListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitResource(@NotNull Java8Parser.ResourceContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPrimary(@NotNull Java8Parser.PrimaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPrimaryNoNewArray(@NotNull Java8Parser.PrimaryNoNewArrayContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPrimaryNoNewArray_lf_arrayAccess(@NotNull Java8Parser.PrimaryNoNewArray_lf_arrayAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPrimaryNoNewArray_lfno_arrayAccess(@NotNull Java8Parser.PrimaryNoNewArray_lfno_arrayAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPrimaryNoNewArray_lf_primary(@NotNull Java8Parser.PrimaryNoNewArray_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(@NotNull Java8Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(@NotNull Java8Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPrimaryNoNewArray_lfno_primary(@NotNull Java8Parser.PrimaryNoNewArray_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(@NotNull Java8Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(@NotNull Java8Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassInstanceCreationExpression(@NotNull Java8Parser.ClassInstanceCreationExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassInstanceCreationExpression_lf_primary(@NotNull Java8Parser.ClassInstanceCreationExpression_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitClassInstanceCreationExpression_lfno_primary(@NotNull Java8Parser.ClassInstanceCreationExpression_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitTypeArgumentsOrDiamond(@NotNull Java8Parser.TypeArgumentsOrDiamondContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitFieldAccess(@NotNull Java8Parser.FieldAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitFieldAccess_lf_primary(@NotNull Java8Parser.FieldAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitFieldAccess_lfno_primary(@NotNull Java8Parser.FieldAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitArrayAccess(@NotNull Java8Parser.ArrayAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitArrayAccess_lf_primary(@NotNull Java8Parser.ArrayAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitArrayAccess_lfno_primary(@NotNull Java8Parser.ArrayAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodInvocation(@NotNull Java8Parser.MethodInvocationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodInvocation_lf_primary(@NotNull Java8Parser.MethodInvocation_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodInvocation_lfno_primary(@NotNull Java8Parser.MethodInvocation_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitArgumentList(@NotNull Java8Parser.ArgumentListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodReference(@NotNull Java8Parser.MethodReferenceContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodReference_lf_primary(@NotNull Java8Parser.MethodReference_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMethodReference_lfno_primary(@NotNull Java8Parser.MethodReference_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitArrayCreationExpression(@NotNull Java8Parser.ArrayCreationExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitDimExprs(@NotNull Java8Parser.DimExprsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitDimExpr(@NotNull Java8Parser.DimExprContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitConstantExpression(@NotNull Java8Parser.ConstantExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitExpression(@NotNull Java8Parser.ExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitLambdaExpression(@NotNull Java8Parser.LambdaExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitLambdaParameters(@NotNull Java8Parser.LambdaParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInferredFormalParameterList(@NotNull Java8Parser.InferredFormalParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitLambdaBody(@NotNull Java8Parser.LambdaBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAssignmentExpression(@NotNull Java8Parser.AssignmentExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAssignment(@NotNull Java8Parser.AssignmentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitLeftHandSide(@NotNull Java8Parser.LeftHandSideContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAssignmentOperator(@NotNull Java8Parser.AssignmentOperatorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitConditionalExpression(@NotNull Java8Parser.ConditionalExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitConditionalOrExpression(@NotNull Java8Parser.ConditionalOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitConditionalAndExpression(@NotNull Java8Parser.ConditionalAndExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitInclusiveOrExpression(@NotNull Java8Parser.InclusiveOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitExclusiveOrExpression(@NotNull Java8Parser.ExclusiveOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAndExpression(@NotNull Java8Parser.AndExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitEqualityExpression(@NotNull Java8Parser.EqualityExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitRelationalExpression(@NotNull Java8Parser.RelationalExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitShiftExpression(@NotNull Java8Parser.ShiftExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitAdditiveExpression(@NotNull Java8Parser.AdditiveExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitMultiplicativeExpression(@NotNull Java8Parser.MultiplicativeExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnaryExpression(@NotNull Java8Parser.UnaryExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPreIncrementExpression(@NotNull Java8Parser.PreIncrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPreDecrementExpression(@NotNull Java8Parser.PreDecrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitUnaryExpressionNotPlusMinus(@NotNull Java8Parser.UnaryExpressionNotPlusMinusContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPostfixExpression(@NotNull Java8Parser.PostfixExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPostIncrementExpression(@NotNull Java8Parser.PostIncrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPostIncrementExpression_lf_postfixExpression(@NotNull Java8Parser.PostIncrementExpression_lf_postfixExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPostDecrementExpression(@NotNull Java8Parser.PostDecrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitPostDecrementExpression_lf_postfixExpression(@NotNull Java8Parser.PostDecrementExpression_lf_postfixExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public Result visitCastExpression(@NotNull Java8Parser.CastExpressionContext ctx) { return visitChildren(ctx); } +} \ No newline at end of file diff --git a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Lexer.java b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Lexer.java new file mode 100644 index 0000000..f4ce1c1 --- /dev/null +++ b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Lexer.java @@ -0,0 +1,601 @@ +// Generated from Java8.g4 by ANTLR 4.5 +package org.nuiton.eugene.plugin.parser.java; + +/* + * #%L + * I18n :: Maven Plugin + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2016 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% + */ + +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 { + } +} \ No newline at end of file diff --git a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Parser.java b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Parser.java new file mode 100644 index 0000000..e555528 --- /dev/null +++ b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Parser.java @@ -0,0 +1,18030 @@ +// Generated from Java8.g4 by ANTLR 4.5 +package org.nuiton.eugene.plugin.parser.java; + +/* + * #%L + * I18n :: Maven Plugin + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2016 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% + */ + +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))) != 0) || ((( [...] + { + { + 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 << SWITCH) | (1L < [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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)) & ((1L << (BANG - 69)) | [...] + { + 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))) != 0) || ((( [...] + { + { + 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 - 68)) | (1L << [...] + { + { + 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 - 69)) & ((1L << [...] + { + 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 - 69)) & ((1L << [...] + { + 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 << SWITCH) | (1L < [...] + { + 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 << SWITCH) | (1 [...] + { + { + 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)) & ((1L << [...] + { + 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 << (BANG - 69)) | ( [...] + { + 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 << (INC - 79)) | (1 [...] + { + 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)) & ((1L << [...] + { + 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 << (BANG - 69)) | ( [...] + { + 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 << (INC - 79)) | (1 [...] + { + 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 << (BANG - 69)) | ( [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | ( [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | ( [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 << (BANG - 69)) | [...] + { + 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 { + } +} \ No newline at end of file diff --git a/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Visitor.java b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Visitor.java new file mode 100644 index 0000000..9db2bf3 --- /dev/null +++ b/eugene-maven-plugin/src/main/java/org/nuiton/eugene/plugin/parser/java/Java8Visitor.java @@ -0,0 +1,1461 @@ +// Generated from Java8.g4 by ANTLR 4.5 +package org.nuiton.eugene.plugin.parser.java; + +/* + * #%L + * I18n :: Maven Plugin + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2016 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% + */ + +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); +} \ No newline at end of file diff --git a/pom.xml b/pom.xml index 268b8f7..df79534 100644 --- a/pom.xml +++ b/pom.xml @@ -120,10 +120,12 @@ <modules> <module>eugene</module> + <module>eugene-config-templates</module> <module>eugene-java-templates</module> <module>eugene-plantuml-templates</module> <module>eugene-yaml-templates</module> <module>eugene-maven-plugin</module> + <module>editor</module> </modules> <scm> @@ -142,6 +144,7 @@ <nuitonI18nVersion>3.6.2</nuitonI18nVersion> <plantumlVersion>8047</plantumlVersion> <snakeyamlVersion>1.17</snakeyamlVersion> + <antlr4Version>4.5</antlr4Version> <!--Multilanguage maven-site --> <locales>en,fr</locales> @@ -203,6 +206,12 @@ </dependency> <dependency> + <groupId>org.nuiton</groupId> + <artifactId>nuiton-config</artifactId> + <version>3.0-rc-4</version> + </dependency> + + <dependency> <groupId>org.nuiton.i18n</groupId> <artifactId>nuiton-i18n</artifactId> <version>${nuitonI18nVersion}</version> @@ -305,6 +314,18 @@ </exclusions> </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.apache.maven</groupId> <artifactId>maven-plugin-api</artifactId> -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.
participants (1)
-
nuiton.org scm