diff --git a/LICENSE b/LICENSE index 67db858821..261eeb9e9f 100644 --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,3 @@ - Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ @@ -173,3 +172,30 @@ defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/NOTICE b/NOTICE index 616fc58894..d8fd6595d9 100644 --- a/NOTICE +++ b/NOTICE @@ -1 +1,5 @@ +AWS Polymorph Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + +This product includes software developed by +Amazon Technologies, Inc (http://www.amazon.com/). diff --git a/README.md b/README.md index 847260ca51..5fa67402c7 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,4 @@ -## My Project - -TODO: Fill this README out! - -Be sure to: - -* Change the title in this README -* Edit your repository description on GitHub +# Polymorph ## Security @@ -14,4 +7,3 @@ See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more inform ## License This project is licensed under the Apache-2.0 License. - diff --git a/smithy-dotnet/.github/CODEOWNERS b/smithy-dotnet/.github/CODEOWNERS new file mode 100644 index 0000000000..8068917362 --- /dev/null +++ b/smithy-dotnet/.github/CODEOWNERS @@ -0,0 +1,5 @@ +# Each line is a file pattern followed by one or more owners. +# https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners + +# Default code owner for everything is our aws-crypto-tools group +* @aws/aws-crypto-tools diff --git a/smithy-dotnet/.gitignore b/smithy-dotnet/.gitignore new file mode 100644 index 0000000000..54caf66065 --- /dev/null +++ b/smithy-dotnet/.gitignore @@ -0,0 +1,7 @@ +# Gradle +/.gradle/ +/build/ +/target/ + +# IDE +/.idea/ diff --git a/smithy-dotnet/README.md b/smithy-dotnet/README.md new file mode 100644 index 0000000000..bb19ab7ce1 --- /dev/null +++ b/smithy-dotnet/README.md @@ -0,0 +1,73 @@ +# smithy-dotnet + +C#/.NET code generation for Smithy models + +## How to use + +This project requires Java 16 or above. + +```bash +$ # start in project root +$ pwd +~/src/polymorph/smithy-dotnet + +$ # build +$ ./gradlew build +BUILD SUCCESSFUL in 507ms + +$ # generate code +$ OUTPUT_DOTNET=/path/to/generated_dotnet +$ OUTPUT_DAFNY=/path/to/generated_dafny +$ MODEL=src/test/resources/model.smithy +$ SERVICE='polymorph.demo#StringLists' +$ ./gradlew run --args="--output-dotnet $OUTPUT_DOTNET --output-dafny $OUTPUT_DAFNY -m $MODEL -s $SERVICE" +[main] INFO software.amazon.polymorph.CodegenCli - .NET code generated in /.../generated-dotnet +[main] INFO software.amazon.polymorph.CodegenCli - Dafny code generated in /.../generated-dafny +``` + +You can also look at the [ServiceCodegenSmokeTest](./src/test/java/software/amazon/polymorph/smithydotnet/ServiceCodegenSmokeTest.java) as a reference for how to use the library. It reads and generates code for the [test model](./src/test/resources/model.smithy), then prints the generated code to stdout. + +## Manual build steps for .NET + +Temporary manual steps for getting the generated code into the .NET ESDK. +Soon this will be replaced by a real Polymorph build process. + +First export some variables indicating where your ESDK model and .NET ESDK live: + +```bash +export MODEL_ROOT= # e.g. ~/src/aws-encryption-sdk-dafny/model +export DOTNET_ROOT= # e.g. ~/src/aws-encryption-sdk-dafny/aws-encryption-sdk-net-formally-verified +export DAFNY_ROOT= # e.g. ~/src/aws-encryption-sdk-dafny +``` + +Then, run the following. You'll likely see a bunch of warnings about "Overwriting existing file". + +```bash +# Generate code for material providers +# NOTE: No Dafny code will be generated, since Dafny codegen doesn't currently support non-AWS-SDK models +./gradlew run --args="\ + --output-dotnet $DOTNET_ROOT/Source/API/Generated/Crypto \ + --output-dafny $DAFNY_ROOT/src/Generated \ + -m $MODEL_ROOT -s aws.crypto#AwsCryptographicMaterialProviders" + +# Generate code for KMS +./gradlew run --args="\ + --output-dotnet $DOTNET_ROOT/Source/API/Generated/Kms \ + --output-dafny $DAFNY_ROOT/src/Generated \ + --aws-sdk \ + -m $MODEL_ROOT -s com.amazonaws.kms#KeyManagementService" + +# Generate code for ESDK +# NOTE: No Dafny code will be generated, since Dafny codegen doesn't currently support non-AWS-SDK models +./gradlew run --args="\ + --output-dotnet $DOTNET_ROOT/Source/API/Generated/Esdk \ + --output-dafny $DAFNY_ROOT/src/Generated \ + -m $MODEL_ROOT -s aws.esdk#AwsEncryptionSdk" +``` + +Confirm the files were generated as expected: + +```bash +ls $DOTNET_ROOT/Source/API/Generated/Crypto +ls $DAFNY_ROOT/src/Generated +``` diff --git a/smithy-dotnet/build.gradle.kts b/smithy-dotnet/build.gradle.kts new file mode 100644 index 0000000000..591384f162 --- /dev/null +++ b/smithy-dotnet/build.gradle.kts @@ -0,0 +1,31 @@ +plugins { + java + application +} + +group = "software.amazon.polymorph" +version = "0.1.0" + +repositories { + mavenLocal() + mavenCentral() +} + +dependencies { + implementation("software.amazon.smithy:smithy-model:1.10.0") + implementation("software.amazon.smithy:smithy-codegen-core:[1.0.2,1.1.0[") + implementation("software.amazon.smithy:smithy-protocol-test-traits:[1.0.2,1.1.0[") + + implementation("com.google.guava:guava:30.1-jre") + implementation("commons-cli:commons-cli:1.4") + implementation("org.slf4j:slf4j-api:1.7.32") + implementation("org.slf4j:slf4j-simple:1.7.32") + + testImplementation("junit", "junit", "4.12") + // Used for parsing-based tests + testImplementation("org.antlr:antlr4:4.9.2") +} + +application { + mainClass.set("software.amazon.polymorph.CodegenCli") +} diff --git a/smithy-dotnet/gradle/wrapper/gradle-wrapper.jar b/smithy-dotnet/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000..e708b1c023 Binary files /dev/null and b/smithy-dotnet/gradle/wrapper/gradle-wrapper.jar differ diff --git a/smithy-dotnet/gradle/wrapper/gradle-wrapper.properties b/smithy-dotnet/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000000..f371643eed --- /dev/null +++ b/smithy-dotnet/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-7.0-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/smithy-dotnet/gradlew b/smithy-dotnet/gradlew new file mode 100755 index 0000000000..4f906e0c81 --- /dev/null +++ b/smithy-dotnet/gradlew @@ -0,0 +1,185 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=`expr $i + 1` + done + case $i in + 0) set -- ;; + 1) set -- "$args0" ;; + 2) set -- "$args0" "$args1" ;; + 3) set -- "$args0" "$args1" "$args2" ;; + 4) set -- "$args0" "$args1" "$args2" "$args3" ;; + 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=`save "$@"` + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +exec "$JAVACMD" "$@" diff --git a/smithy-dotnet/gradlew.bat b/smithy-dotnet/gradlew.bat new file mode 100644 index 0000000000..ac1b06f938 --- /dev/null +++ b/smithy-dotnet/gradlew.bat @@ -0,0 +1,89 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/smithy-dotnet/settings.gradle b/smithy-dotnet/settings.gradle new file mode 100644 index 0000000000..818d4ccbc8 --- /dev/null +++ b/smithy-dotnet/settings.gradle @@ -0,0 +1,2 @@ +rootProject.name = 'smithy-dotnet' + diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/CodegenCli.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/CodegenCli.java new file mode 100644 index 0000000000..7a7e3f3b3e --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/CodegenCli.java @@ -0,0 +1,189 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph; + +import org.apache.commons.cli.CommandLine; +import org.apache.commons.cli.DefaultParser; +import org.apache.commons.cli.HelpFormatter; +import org.apache.commons.cli.Option; +import org.apache.commons.cli.Options; +import org.apache.commons.cli.ParseException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import software.amazon.polymorph.smithydafny.DafnyApiCodegen; +import software.amazon.polymorph.smithydotnet.AwsSdkShimCodegen; +import software.amazon.polymorph.smithydotnet.AwsSdkTypeConversionCodegen; +import software.amazon.polymorph.smithydotnet.ServiceCodegen; +import software.amazon.polymorph.smithydotnet.ShimCodegen; +import software.amazon.polymorph.smithydotnet.TypeConversionCodegen; +import software.amazon.polymorph.utils.TokenTree; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.loader.ModelAssembler; +import software.amazon.smithy.model.shapes.ShapeId; + +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.Map; +import java.util.Optional; + +public class CodegenCli { + private static final Logger logger = LoggerFactory.getLogger(CodegenCli.class); + + public static void main(String[] args) { + Optional cliArgumentsOptional = Optional.empty(); + try { + cliArgumentsOptional = CliArguments.parse(args); + } catch (ParseException e) { + logger.error("Command-line arguments could not be parsed", e); + } + if (cliArgumentsOptional.isEmpty()) { + printHelpMessage(); + System.exit(0); + } + final CliArguments cliArguments = cliArgumentsOptional.get(); + + final Path outputDotnetDir = cliArguments.outputDotnetDir; + final Path outputDafnyDir = cliArguments.outputDafnyDir; + try { + Files.createDirectories(outputDotnetDir); + Files.createDirectories(outputDafnyDir); + } catch (IOException e) { + e.printStackTrace(); + System.exit(1); + } + + final ModelAssembler assembler = new ModelAssembler(); + final Model model = assembler.addImport(cliArguments.modelPath).assemble().unwrap(); + + if (!cliArguments.awsSdkStyle) { + final ServiceCodegen serviceCodegen = new ServiceCodegen(model, cliArguments.serviceShapeId); + writeTokenTreesIntoDir(serviceCodegen.generate(), outputDotnetDir); + + final ShimCodegen shimCodegen = new ShimCodegen(model, cliArguments.serviceShapeId); + writeTokenTreesIntoDir(shimCodegen.generate(), outputDotnetDir); + } + + final TypeConversionCodegen typeConversionCodegen = cliArguments.awsSdkStyle + ? new AwsSdkTypeConversionCodegen(model, cliArguments.serviceShapeId) + : new TypeConversionCodegen(model, cliArguments.serviceShapeId); + writeTokenTreesIntoDir(typeConversionCodegen.generate(), outputDotnetDir); + + if (cliArguments.awsSdkStyle) { + // TODO generate Dafny API for regular models too + final DafnyApiCodegen dafnyApiCodegen = new DafnyApiCodegen(model, cliArguments.serviceShapeId); + writeTokenTreesIntoDir(dafnyApiCodegen.generate(), outputDafnyDir); + + final AwsSdkShimCodegen shimCodegen = new AwsSdkShimCodegen(model, cliArguments.serviceShapeId); + writeTokenTreesIntoDir(shimCodegen.generate(), outputDotnetDir); + } + + logger.info(".NET code generated in {}", cliArguments.outputDotnetDir); + logger.info("Dafny code generated in {}", cliArguments.outputDafnyDir); + } + + private static Options getCliOptions() { + final Options cliOptions = new Options(); + cliOptions.addOption(Option.builder("h") + .longOpt("help") + .desc("print help message") + .build()); + cliOptions.addOption(Option.builder("m") + .longOpt("model") + .desc("model file (.smithy format)") + .hasArg() + .required() + .build()); + cliOptions.addOption(Option.builder("s") + .longOpt("service-id") + .desc("service ID to generate code for, such as 'com.foo#BarService'") + .hasArg() + .required() + .build()); + cliOptions.addOption(Option.builder() + .longOpt("output-dotnet") + .desc("output directory for generated .NET files") + .hasArg() + .required() + .build()); + cliOptions.addOption(Option.builder() + .longOpt("output-dafny") + .desc("output directory for generated Dafny files") + .hasArg() + .required() + .build()); + cliOptions.addOption(Option.builder() + .longOpt("aws-sdk") + .desc("generate AWS SDK-style API and shims") + .build()); + return cliOptions; + } + + private static void printHelpMessage() { + new HelpFormatter().printHelp("smithy-dotnet", getCliOptions()); + } + + private static record CliArguments( + Path modelPath, + ShapeId serviceShapeId, + Path outputDotnetDir, + Path outputDafnyDir, + boolean awsSdkStyle + ) { + /** + * @param args arguments to parse + * @return parsed arguments, or {@code Optional.empty()} if help should be printed + * @throws ParseException if command line arguments are invalid + */ + static Optional parse(String[] args) throws ParseException { + final DefaultParser parser = new DefaultParser(); + final CommandLine commandLine = parser.parse(getCliOptions(), args); + if (commandLine.hasOption("h")) { + return Optional.empty(); + } + + final Path modelPath = Path.of(commandLine.getOptionValue('m')); + final ShapeId serviceShapeId = ShapeId.from(commandLine.getOptionValue('s')); + final Path outputDotnetDir = Paths.get(commandLine.getOptionValue("output-dotnet")) + .toAbsolutePath().normalize(); + final Path outputDafnyDir = Paths.get(commandLine.getOptionValue("output-dafny")) + .toAbsolutePath().normalize(); + final boolean awsSdkStyle = commandLine.hasOption("aws-sdk"); + + return Optional.of(new CliArguments( + modelPath, serviceShapeId, outputDotnetDir, outputDafnyDir, awsSdkStyle)); + } + } + + private static void writeToFile(final String text, final File file) { + try { + if (!file.createNewFile()) { + logger.warn("Overwriting existing file {}", file); + } + final FileWriter fileWriter = new FileWriter(file); + fileWriter.write(text); + fileWriter.close(); + } catch (IOException e) { + logger.error("Could not write to file {}", file); + e.printStackTrace(); + } + } + + private static final String COPYRIGHT_HEADER = """ + // Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. + // SPDX-License-Identifier: Apache-2.0 + """; + + private static void writeTokenTreesIntoDir(final Map tokenTreeMap, final Path outputDir) { + tokenTreeMap.forEach((Path localPath, TokenTree tokens) -> { + final Path outputPath = Path.of(outputDir.toString(), localPath.toString()); + writeToFile(COPYRIGHT_HEADER + tokens.toString(), outputPath.toFile()); + }); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydafny/DafnyApiCodegen.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydafny/DafnyApiCodegen.java new file mode 100644 index 0000000000..9e252d5bb3 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydafny/DafnyApiCodegen.java @@ -0,0 +1,462 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydafny; + +import software.amazon.polymorph.traits.DafnyUtf8BytesTrait; +import software.amazon.polymorph.traits.PositionalTrait; +import software.amazon.polymorph.traits.ReferenceTrait; +import software.amazon.polymorph.utils.ModelUtils; +import software.amazon.polymorph.utils.Token; +import software.amazon.polymorph.utils.TokenTree; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.BlobShape; +import software.amazon.smithy.model.shapes.ListShape; +import software.amazon.smithy.model.shapes.MapShape; +import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.NumberShape; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.ShapeType; +import software.amazon.smithy.model.shapes.StringShape; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.EnumTrait; +import software.amazon.smithy.model.traits.ErrorTrait; +import software.amazon.smithy.model.traits.LengthTrait; +import software.amazon.smithy.model.traits.RangeTrait; +import software.amazon.smithy.model.traits.TraitDefinition; + +import java.nio.file.Path; +import java.util.Arrays; +import java.util.Collection; +import java.util.Comparator; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.TreeSet; +import java.util.stream.Collectors; + +public class DafnyApiCodegen { + private final Model model; + private final ServiceShape serviceShape; + private final DafnyNameResolver nameResolver; + + public DafnyApiCodegen(final Model model, final ShapeId serviceShapeId) { + this.model = model; + this.serviceShape = model.expectShape(serviceShapeId, ServiceShape.class); + this.nameResolver = new DafnyNameResolver(model, serviceShape); + } + + public Map generate() { + final TokenTree includeDirectives = Token.of(""" + include "../StandardLibrary/StandardLibrary.dfy" + include "../Util/UTF8.dfy" + """); + + final String serviceName = nameResolver.nameForService(); + final String externNamespace = DafnyNameResolver.dafnyExternNamespaceForShapeId(serviceShape.getId()); + final String moduleName = DafnyNameResolver.dafnyModuleForShapeId(serviceShape.getId()); + final TokenTree moduleHeader = Token.of("module {:extern \"%s\"} %s".formatted(externNamespace, moduleName)); + + final TokenTree modulePrelude = Token.of(""" + import opened Wrappers + import opened StandardLibrary.UInt + import opened UTF8 + """); + final TokenTree generatedTypes = TokenTree.of(model.shapes() + .filter(shape -> ModelUtils.isInServiceNamespace(shape.getId(), serviceShape)) + // Sort by shape ID for deterministic generated code + .collect(Collectors.toCollection(() -> new TreeSet<>(new ShapeIdComparator()))) + .stream() + .map(this::generateCodeForShape) + .flatMap(Optional::stream) + ).lineSeparated(); + + final TokenTree moduleBody = TokenTree.of(modulePrelude, generatedTypes).braced(); + + final Path path = Path.of("%s.dfy".formatted(serviceName)); + final TokenTree fullCode = TokenTree.of(includeDirectives, moduleHeader, moduleBody); + return Map.of(path, fullCode); + } + + private static class ShapeIdComparator implements Comparator { + @Override + public int compare(Shape o1, Shape o2) { + return o1.getId().compareTo(o2.getId()); + } + } + + private Optional generateCodeForShape(final Shape shape) { + final ShapeId shapeId = shape.getId(); + return Optional.ofNullable(switch (shape.getType()) { + case SERVICE -> { + if (shape != serviceShape) { + throw new IllegalStateException("Unexpected service shape found"); + } + yield TokenTree.of(generateServiceTraitDefinition(), generateServiceErrorTypeDefinition()) + .lineSeparated(); + } + case BLOB -> generateBlobTypeDefinition(shapeId); + case BOOLEAN -> generateBoolTypeDefinition(shapeId); + case STRING -> { + if (shape.hasTrait(EnumTrait.class)) { + yield generateEnumTypeDefinition(shapeId); + } else if (shape.hasTrait(DafnyUtf8BytesTrait.ID)) { + yield generateValidUTF8BytesType(shapeId); + } else { + yield generateStringTypeDefinition(shapeId); + } + } + case INTEGER, LONG -> generateNumericTypeDefinition(shapeId); + case LIST -> generateListTypeDefinition(shapeId); + case MAP -> generateMapTypeDefinition(shapeId); + case STRUCTURE -> { + if (shape.hasTrait(TraitDefinition.class) + || shape.hasTrait(ReferenceTrait.class) + || shape.hasTrait(PositionalTrait.class)) { + yield null; + } else if (shape.hasTrait(ErrorTrait.class)) { + yield generateErrorStructureTypeDefinition(shapeId); + } else { + yield generateStructureTypeDefinition(shapeId); + } + } + default -> null; + }); + } + + public TokenTree generateValidUTF8BytesType(final ShapeId shapeId) { + final StringShape stringShape = model.expectShape(shapeId, StringShape.class); + final Optional lengthConstraint = stringShape + .getTrait(LengthTrait.class) + .map(DafnyApiCodegen::generateLengthConstraint); + return generateSubsetType(shapeId, "ValidUTF8Bytes", lengthConstraint); + } + + public TokenTree generateErrorStructureTypeDefinition(final ShapeId shapeId) { + TokenTree datatype = this.generateStructureTypeDefinition(shapeId); + StructureShape errorStructure = model.expectShape(shapeId, StructureShape.class); + final TokenTree castMethod = generateCastToStringForAnErrorStructure(shapeId, errorStructure); + datatype = datatype.append(castMethod.surround(TokenTree.of("{\n"), TokenTree.of("\n }"))); + return datatype; + } + + public TokenTree generateCastToStringForAnErrorStructure(final ShapeId shapeId, final StructureShape errorStructure) { + Optional message = errorStructure.getMember("message"); + final String castToStringSignature = "\tfunction method CastToString(): string {\n\t%1$s\n\t}"; + String body; + if (message.isPresent() + && model.expectShape(message.get().getTarget()).getType() == ShapeType.STRING) { + body = "\tif message.Some? then \"%1$s: \" + message.value else \"%1$s\""; + } else { + body = "\"%1$s\""; + } + body = body.formatted(shapeId.getName(serviceShape)); + TokenTree castMethod = TokenTree.of(castToStringSignature.formatted(body)); + return castMethod; + } + + public TokenTree generateBlobTypeDefinition(final ShapeId blobShapeId) { + final BlobShape blobShape = model.expectShape(blobShapeId, BlobShape.class); + final Optional lengthConstraint = blobShape.getTrait(LengthTrait.class) + .map(DafnyApiCodegen::generateLengthConstraint); + return generateSubsetType(blobShapeId, "seq", lengthConstraint); + } + + public TokenTree generateBoolTypeDefinition(final ShapeId boolShapeId) { + return generateTypeSynonym(boolShapeId, "bool"); + } + + public TokenTree generateStringTypeDefinition(final ShapeId stringShapeId) { + final StringShape stringShape = model.expectShape(stringShapeId, StringShape.class); + final Optional lengthConstraint = stringShape.getTrait(LengthTrait.class) + .map(DafnyApiCodegen::generateLengthConstraint); + return generateSubsetType(stringShapeId, "string", lengthConstraint); + } + + public TokenTree generateEnumTypeDefinition(final ShapeId stringShapeId) { + final StringShape stringShape = model.expectShape(stringShapeId, StringShape.class); + final EnumTrait enumTrait = stringShape.getTrait(EnumTrait.class).orElseThrow(); + + if (!enumTrait.hasNames()) { + throw new UnsupportedOperationException("Unnamed enums not supported"); + } + //noinspection OptionalGetWithoutIsPresent + final TokenTree constructors = TokenTree.of(enumTrait.getValues().stream() + .map(enumDefinition -> enumDefinition.getName().get()) + .peek(name -> { + if (!ModelUtils.isValidEnumDefinitionName(name)) { + throw new UnsupportedOperationException("Invalid enum definition name: %s".formatted(name)); + } + }) + .map(name -> TokenTree.of("\n\t|", name))); + + return Token.of("datatype %s =".formatted(nameResolver.baseTypeForShape(stringShapeId))).append(constructors); + } + + public TokenTree generateNumericTypeDefinition(final ShapeId numberShapeId) { + final NumberShape numberShape = model.expectShape(numberShapeId, NumberShape.class); + final Optional rangeConstraint = numberShape.getTrait(RangeTrait.class) + .map(DafnyApiCodegen::generateRangeConstraint); + final String baseType = Objects.requireNonNull( + DafnyNameResolver.DAFNY_TYPES_BY_SIMPLE_SHAPE_TYPE.get(numberShape.getType())); + return generateSubsetType(numberShapeId, baseType, rangeConstraint); + } + + public TokenTree generateListTypeDefinition(final ShapeId listShapeId) { + final ListShape listShape = model.expectShape(listShapeId, ListShape.class); + final Optional lengthConstraint = listShape.getTrait(LengthTrait.class) + .map(DafnyApiCodegen::generateLengthConstraint); + final String baseType = "seq<%s>".formatted(nameResolver.baseTypeForShape(listShape.getMember().getId())); + return generateSubsetType(listShapeId, baseType, lengthConstraint); + } + + public TokenTree generateMapTypeDefinition(final ShapeId mapShapeId) { + final MapShape mapShape = model.expectShape(mapShapeId, MapShape.class); + final Optional lengthConstraint = mapShape.getTrait(LengthTrait.class) + .map(DafnyApiCodegen::generateLengthConstraint); + final String keyType = nameResolver.baseTypeForShape(mapShape.getKey().getId()); + final String valueType = nameResolver.baseTypeForShape(mapShape.getValue().getId()); + final String baseType = "map<%s, %s>".formatted(keyType, valueType); + return generateSubsetType(mapShapeId, baseType, lengthConstraint); + } + + public TokenTree generateStructureTypeDefinition(final ShapeId structureShapeId) { + final StructureShape structureShape = model.expectShape(structureShapeId, StructureShape.class); + final TokenTree params = TokenTree.of(ModelUtils.streamStructureMembers(structureShape) + .map(this::generateStructureTypeParameter) + ).separated(Token.of(",")).parenthesized(); + + final String typeName = structureShapeId.getName(serviceShape); + return TokenTree.of( + Token.of("datatype %1$s = %1$s".formatted(typeName)), + params); + } + + private TokenTree generateStructureTypeParameter(final MemberShape memberShape) { + return Token.of("\n\tnameonly %s: %s".formatted( + memberShape.getMemberName(), nameResolver.baseTypeForShape(memberShape.getId()))); + } + + public TokenTree generateServiceTraitDefinition() { + final TokenTree trait = TokenTree.of("trait", nameResolver.traitForServiceClient(serviceShape)); + final TokenTree predicatesAndMethods = TokenTree.of( + serviceShape.getAllOperations().stream().map(this::generateOperationPredicatesAndMethod)) + .lineSeparated(); + return TokenTree.of(trait, predicatesAndMethods.braced()); + } + + public TokenTree generateOperationPredicatesAndMethod(final ShapeId operationShapeId) { + + final OperationShape operationShape = model.expectShape(operationShapeId, OperationShape.class); + final TokenTree operationParams = operationShape.getInput() + .map(nameResolver::baseTypeForShape) + .map(inputType -> TokenTree.of("input:", inputType)) + .orElse(TokenTree.empty()) + ; + final Optional outputType = this.nameResolver.returnTypeForResult(operationShape); + TokenTree returnType = TokenTree.empty(); + if (outputType.isPresent()) { + returnType = TokenTree.of("output: %s".formatted(outputType.get())); + } + + final TokenTree wrappedReply = Token.of("output: %s" + .formatted(nameResolver.returnTypeForOperation(operationShape))); + final TokenTree calledWithPredicate = this.generatePredicateCalledWith(operationShape, operationParams); + final TokenTree succeededWithPredicate = this.generatePredicateSucceededWith(operationShape, operationParams, returnType); + final TokenTree method = this.generateOperationMethod(operationShape, operationParams, wrappedReply); + + return TokenTree.of(calledWithPredicate, succeededWithPredicate, method).lineSeparated().append(TokenTree.of("\n")); + } + + private TokenTree generateOperationMethod( + final OperationShape operationShape, + final TokenTree operationParams, + final TokenTree wrappedReply + ) { + final TokenTree name = TokenTree.of("method", nameResolver.methodForOperation(operationShape)); + final TokenTree params = operationParams.parenthesized(); + final TokenTree returns = TokenTree.of("returns ").append(wrappedReply.parenthesized()); + + // The formal Dafny name for this section of a method is "specification". + // To avoid confusion with RFC-style "specifications", instead use the term "conditions". + TokenTree conditions = TokenTree.empty(); + + TokenTree ensureCalledWith = TokenTree.of( + "\n\tensures " + + nameResolver.predicateCalledWith(operationShape) + ); + TokenTree ensureSucceededWith = TokenTree.of( + "\n\tensures output.Success? ==> " + + nameResolver.predicateSucceededWith(operationShape) + ); + TokenTree ensureCalledWithParams = TokenTree.empty(); + TokenTree ensureSucceededWithParams = TokenTree.empty(); + if (operationShape.getInput().isPresent()) { + ensureCalledWithParams = ensureCalledWithParams.append(TokenTree.of("input")); + ensureSucceededWithParams = ensureSucceededWithParams.append(TokenTree.of("input")); + } + if (operationShape.getInput().isPresent() && operationShape.getOutput().isPresent()) { + ensureSucceededWithParams = ensureSucceededWithParams.append(TokenTree.of(",")); + } + if (operationShape.getOutput().isPresent()) { + ensureSucceededWithParams = ensureSucceededWithParams.append(TokenTree.of("output.value")); + } + ensureCalledWithParams = ensureCalledWithParams.parenthesized(); + ensureSucceededWithParams = ensureSucceededWithParams.parenthesized(); + + ensureCalledWith = ensureCalledWith.append(ensureCalledWithParams); + ensureSucceededWith = ensureSucceededWith.append(ensureSucceededWithParams); + conditions = conditions.append(ensureCalledWith); + conditions = conditions.append(ensureSucceededWith); + return TokenTree.of(name, params, returns, conditions); + } + + private TokenTree generatePredicateCalledWith( + final OperationShape operationShape, + final TokenTree operationParams + ) { + final TokenTree name = TokenTree.of("predicate {:opaque}", nameResolver.predicateCalledWith(operationShape)); + TokenTree params = TokenTree.of("("); + if (operationShape.getInput().isPresent()) { + params = TokenTree.of(params, operationParams); + } + params = params.append(TokenTree.of(")")); + final TokenTree body = TokenTree.of("{true}"); + return TokenTree.of(name, params, body); + } + + private TokenTree generatePredicateSucceededWith( + final OperationShape operationShape, + final TokenTree operationParams, + final TokenTree returnType + ) { + TokenTree params = TokenTree.empty(); + if (operationShape.getInput().isPresent()) { + params = TokenTree.of(params, operationParams); + } + if (operationShape.getInput().isPresent() && operationShape.getOutput().isPresent()) { + params = params.append(TokenTree.of(",")); + } + if (operationShape.getOutput().isPresent()) { + params = params.append(returnType); + } + params = params.parenthesized(); + final TokenTree name = TokenTree.of("predicate {:opaque}", nameResolver.predicateSucceededWith(operationShape)); + final TokenTree body = TokenTree.of("{true}"); + return TokenTree.of(name, params, body); + } + + /** + * Generates a sum type for the error shapes of operations in the service. + */ + // TODO: once traits can be used as type parameters, make this a trait instead so that we don't + // need to exhaustively specify the error shapes of operations + public TokenTree generateServiceErrorTypeDefinition() { + // Collect into TreeSet so that the error shapes are lexicographically sorted, ordering them deterministically + final TreeSet errorShapeIds = ModelUtils.streamServiceErrors(model, serviceShape) + .map(Shape::getId) + .collect(Collectors.toCollection(TreeSet::new)); + + final TokenTree unknownConstructor = Token.of("| %s(unknownMessage: string)".formatted( + nameResolver.nameForServiceErrorUnknownConstructor(serviceShape))); + final TokenTree knownConstructors = TokenTree.of(errorShapeIds.stream() + .map(errorShapeId -> Token.of("| %1$s(%2$s: %2$s)".formatted( + nameResolver.nameForServiceErrorConstructor(errorShapeId), nameResolver.baseTypeForShape(errorShapeId))))) + .lineSeparated(); + final TokenTree allConstructors = TokenTree.of(unknownConstructor, knownConstructors).lineSeparated(); + TokenTree serviceErrorDatatype = TokenTree.of("datatype", nameResolver.errorTypeForService(serviceShape), "=\n") + .append(allConstructors); + + return serviceErrorDatatype + .append(generateCastToStringForErrorStructure(errorShapeIds)) + .lineSeparated(); + } + + /** + * Generates a function method to cast all subtypes of generated Service Error + * to a string. + */ + public TokenTree generateCastToStringForErrorStructure(final TreeSet errorShapeIds) { + String castToStringFunctionMethodName = "Cast" + + nameResolver.errorTypeForService(serviceShape) + + "ToString"; + TokenTree castToStringSignature = TokenTree.of("function method %1$s(error: %2$s): string".formatted( + castToStringFunctionMethodName, nameResolver.errorTypeForService(serviceShape))); + final String commonCaseBody = "\n\tcase %1$s(arg) => arg.CastToString()"; + final TokenTree body = TokenTree.of(errorShapeIds.stream() + .map(errorShapeId -> TokenTree.of(commonCaseBody.formatted( + nameResolver.nameForServiceErrorConstructor(errorShapeId))))) + .surround( + TokenTree.of("\tmatch error"), + TokenTree.of("\n\tcase %1$s(arg) => \"Unexpected Exception from AWS %2$s: \" + arg".formatted( + nameResolver.nameForServiceErrorUnknownConstructor(serviceShape), + nameResolver.nameForService()))) + .braced(); + return castToStringSignature.append(body); + } + + private static TokenTree generateLengthConstraint(final LengthTrait lengthTrait) { + final String min = lengthTrait.getMin().map("%s <="::formatted).orElse(""); + final String max = lengthTrait.getMax().map("<= %s"::formatted).orElse(""); + return TokenTree.of(min, "|x|", max); + } + + private static TokenTree generateRangeConstraint(final RangeTrait rangeTrait) { + final String min = rangeTrait.getMin().map("%s <="::formatted).orElse(""); + final String max = rangeTrait.getMax().map("<= %s"::formatted).orElse(""); + return TokenTree.of(min, "x", max); + } + + /** + * Given a name {@code TypeName}, base type {@code BaseType}, and constraint predicate expressions + * {@code c1, c2, ..., cN} over a free variable {@code x}, generates a subset type like + * 
+     * type TypeName = x: BaseType | (c1) && (c2) && ... && (cN) witness *
+     *
+ * + * If no constraint expressions are provided, then instead generates a type synonym like + * 
+     * type TypeName = BaseType
+     *
+ */ + private TokenTree generateSubsetType( + final ShapeId shapeId, final String baseType, final Collection constraints) { + final String typeName = nameResolver.generatedTypeForShape(shapeId); + if (constraints.size() == 0) { + return TokenTree.of("type", typeName, "=", baseType); + } + + final TokenTree constraintsConjunct = TokenTree.of(constraints.stream().map(TokenTree::parenthesized)) + .separated(Token.of("&&")); + final String validityPredicateName = nameResolver.validityPredicateForShape(shapeId); + final TokenTree validityPredicate = Token.of( + "predicate method %s(x: %s)".formatted(validityPredicateName, baseType)) + .append(constraintsConjunct.braced()); + final TokenTree subsetType = + Token.of("type %s = x: %s | %s(x) witness *".formatted(typeName, baseType, validityPredicateName)); + + return TokenTree.of(subsetType, validityPredicate).lineSeparated(); + } + + /** + * Like {@link DafnyApiCodegen#generateSubsetType(ShapeId, String, Collection)}, but accepts + * {@link Optional}-wrapped constraints and discards the empty ones. + */ + @SuppressWarnings("JavaDoc") + @SafeVarargs + private TokenTree generateSubsetType( + final ShapeId shapeId, final String baseType, final Optional... constraintOptionals) { + final List constraints = Arrays.stream(constraintOptionals).flatMap(Optional::stream).toList(); + return generateSubsetType(shapeId, baseType, constraints); + } + + @SuppressWarnings("SameParameterValue") + private TokenTree generateTypeSynonym( + final ShapeId shapeId, final String baseType) { + return generateSubsetType(shapeId, baseType, Optional.empty()); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydafny/DafnyNameResolver.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydafny/DafnyNameResolver.java new file mode 100644 index 0000000000..afb8b091c2 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydafny/DafnyNameResolver.java @@ -0,0 +1,173 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydafny; + +import com.google.common.base.Joiner; + +import software.amazon.polymorph.traits.ReferenceTrait; +import software.amazon.polymorph.utils.ModelUtils; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ResourceShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.ShapeType; +import software.amazon.smithy.utils.StringUtils; + +import javax.annotation.Nullable; +import java.util.Arrays; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.stream.Stream; + +public record DafnyNameResolver(Model model, ServiceShape serviceShape) { + public static final Map DAFNY_TYPES_BY_SIMPLE_SHAPE_TYPE = Map.ofEntries( + Map.entry(ShapeType.BLOB, "seq"), + Map.entry(ShapeType.BOOLEAN, "bool"), + Map.entry(ShapeType.STRING, "string"), + // currently unused in model and unsupported in StandardLibrary.UInt +// Map.entry(ShapeType.BYTE, "int8"), +// Map.entry(ShapeType.SHORT, "int16"), + Map.entry(ShapeType.INTEGER, "int32"), + Map.entry(ShapeType.LONG, "int64") + ); + + public String nameForService(final ServiceShape serviceShape) { + return StringUtils.capitalize(serviceShape.getContextualName(this.serviceShape)); + } + + public String nameForService() { + return nameForService(serviceShape); + } + + public String nameForServiceErrorConstructor(final ShapeId errorShapeId) { + return "%1$s_%2$s".formatted(this.nameForService(), this.baseTypeForShape(errorShapeId)); + } + + public String nameForServiceErrorUnknownConstructor(final ServiceShape serviceShape) { + return "%s_Unknown".formatted(nameForService(serviceShape)); + } + + @SuppressWarnings("OptionalGetWithoutIsPresent") + public String baseTypeForShape(final ShapeId shapeId) { + final Shape shape = model.expectShape(shapeId); + final String shapeName = shapeId.getName(serviceShape); + + if (ModelUtils.isSmithyApiShape(shapeId)) { + @Nullable final String simpleShapeType = DAFNY_TYPES_BY_SIMPLE_SHAPE_TYPE.get(shape.getType()); + return Objects.requireNonNull(simpleShapeType, + () -> String.format("No Dafny type for prelude shape %s", shapeId)); + } + + return switch (shape.getType()) { + case BLOB, BOOLEAN, STRING, + // currently unused in model and unsupported in StandardLibrary.UInt + // BYTE, SHORT + INTEGER, LONG, + LIST, MAP, STRUCTURE -> shapeName; + case SERVICE -> traitForServiceClient(shape.asServiceShape().get()); + case RESOURCE -> traitForResource(shape.asResourceShape().get()); + case MEMBER -> baseTypeForMember(shape.asMemberShape().get()); + // TODO create/use better timestamp type in Dafny libraries + case TIMESTAMP -> "string"; + default -> throw new UnsupportedOperationException( + "Shape %s has unsupported type %s".formatted(shapeId, shape.getType())); + }; + } + + private String baseTypeForMember(final MemberShape memberShape) { + final String targetType = baseTypeForShape(memberShape.getTarget()); + if (!ModelUtils.memberShapeIsOptional(model, memberShape)) { + return targetType; + } + + // Entity references are represented as Dafny traits, and Dafny traits can't be type parameters. So in the + // Dafny implementation of the model, an optional entity reference member is represented as a nullable type T? + // instead of an Optional. This works around the limitation. + // TODO: remove workaround when https://github.com/dafny-lang/dafny/issues/1499 is resolved + final boolean targetIsEntityReference = Optional.of(memberShape.getTarget()) + .flatMap(model::getShape) + .flatMap(targetShape -> targetShape.getTrait(ReferenceTrait.class)) + .isPresent(); + return (targetIsEntityReference ? "%s?" : "Option<%s>").formatted(targetType); + + } + + public String generatedTypeForShape(final ShapeId shapeId) { + return StringUtils.capitalize(shapeId.getName(serviceShape)); + } + + public String traitForServiceClient(final ServiceShape serviceShape) { + return "I%sClient".formatted(nameForService(serviceShape)); + } + + public String traitForResource(final ResourceShape resourceShape) { + final String resourceName = StringUtils.capitalize(resourceShape.getId().getName(this.serviceShape)); + return "I%s".formatted(resourceName); + } + + public String errorTypeForService(final ServiceShape serviceShape) { + return "%sError".formatted(nameForService(serviceShape)); + } + + public String methodForOperation(final OperationShape operationShape) { + return StringUtils.capitalize(operationShape.getId().getName(serviceShape)); + } + + public String predicateCalledWith(final OperationShape operationShape) { + return "%sCalledWith".formatted(this.methodForOperation(operationShape)); + } + + /** + * Returns the return type for an operation of this service. + * This is {@code Result}, + * where {@code T} is either... + *
    + *
  • ... the corresponding Dafny output type, if the operation has output.
    • + *
  • ... {@code ()} ("unit"), if the operation does not have output.
    • + *
+ */ + public String returnTypeForOperation(final OperationShape operationShape) { + final String outputType = operationShape.getOutput() + .map(this::baseTypeForShape) + .orElse("()"); + return "Result<%s, %s>".formatted(outputType, errorTypeForService(serviceShape)); + } + + public Optional returnTypeForResult(final OperationShape operationShape) { + if (operationShape.getOutput().isPresent()) { + return Optional.of(this.baseTypeForShape(operationShape.getOutput().get())); + } + return Optional.empty(); + } + + public String validityPredicateForShape(final ShapeId shapeId) { + final String unqualifiedTypeName = baseTypeForShape(shapeId); + return "IsValid_%s".formatted(unqualifiedTypeName); + } + + /** + * Returns the Dafny module corresponding to the namespace of the given shape ID. + */ + public static String dafnyModuleForShapeId(final ShapeId shapeId) { + final Stream namespaceParts = Arrays + .stream(shapeId.getNamespace().split("\\.")) + .map(StringUtils::capitalize); + return Joiner.on('.').join(namespaceParts.iterator()); + } + + /** + * Returns the Dafny {@code {:extern}} namespace corresponding to the namespace of the given shape ID. + */ + public static String dafnyExternNamespaceForShapeId(final ShapeId shapeId) { + return "Dafny." + dafnyModuleForShapeId(shapeId); + } + + public String predicateSucceededWith(OperationShape operationShape) { + return "%sSucceededWith".formatted(this.methodForOperation(operationShape)); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/AwsSdkDotNetNameResolver.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/AwsSdkDotNetNameResolver.java new file mode 100644 index 0000000000..70a6e89bc7 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/AwsSdkDotNetNameResolver.java @@ -0,0 +1,86 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import software.amazon.polymorph.utils.ModelUtils; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.ListShape; +import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StringShape; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.EnumTrait; +import software.amazon.smithy.model.traits.TraitDefinition; +import software.amazon.smithy.utils.StringUtils; + +public class AwsSdkDotNetNameResolver extends DotNetNameResolver { + public AwsSdkDotNetNameResolver(final Model model, final ServiceShape serviceShape) { + super(model, serviceShape); + } + + private boolean isGeneratedInSdk(final ShapeId shapeId) { + return ModelUtils.isInServiceNamespace(shapeId, getServiceShape()); + } + + @Override + protected String baseTypeForString(final StringShape stringShape) { + if (isGeneratedInSdk(stringShape.getId()) && stringShape.hasTrait(EnumTrait.class)) { + return "%s.%s".formatted(getSdkServiceNamespace(), classForEnum(stringShape.getId())); + } + + return super.baseTypeForString(stringShape); + } + + @Override + protected String baseTypeForList(final ListShape listShape) { + final MemberShape memberShape = listShape.getMember(); + final Shape targetShape = getModel().expectShape(memberShape.getTarget()); + + // The .NET AWS SDK represents a list-of-enums as a list-of-strings, even though it represents enums as the + // corresponding enum class every where else AFAICT. + final String memberType = targetShape.hasTrait(EnumTrait.class) ? "string" : baseTypeForMember(memberShape); + + return "System.Collections.Generic.List<%s>".formatted(memberType); + } + + @Override + protected String baseTypeForStructure(final StructureShape structureShape) { + if (isGeneratedInSdk(structureShape.getId()) && !structureShape.hasTrait(TraitDefinition.class)) { + return "%s.Model.%s".formatted(getSdkServiceNamespace(), classForStructure(structureShape.getId())); + } + + return super.baseTypeForStructure(structureShape); + } + + @Override + protected String baseTypeForService(final ServiceShape serviceShape) { + if (isGeneratedInSdk(serviceShape.getId())) { + return "%s.IAmazon%s".formatted(getSdkServiceNamespace(), getServiceName()); + } + + return super.baseTypeForService(serviceShape); + } + + public String implForServiceClient() { + return "%s.Amazon%sClient".formatted(getSdkServiceNamespace(), getServiceName()); + } + + private String getServiceName() { + return StringUtils.capitalize(getServiceShape().getId().getName()); + } + + private String getSdkServiceNamespace() { + return "Amazon.%s".formatted(getServiceName()); + } + + public String shimClassForService() { + return "%sShim".formatted(getServiceName()); + } + + public String baseExceptionForService() { + return "%s.Amazon%sException".formatted(getSdkServiceNamespace(), getServiceName()); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/AwsSdkShimCodegen.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/AwsSdkShimCodegen.java new file mode 100644 index 0000000000..8ea172ab3e --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/AwsSdkShimCodegen.java @@ -0,0 +1,173 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import software.amazon.polymorph.smithydafny.DafnyNameResolver; +import software.amazon.polymorph.utils.ModelUtils; +import software.amazon.polymorph.utils.Token; +import software.amazon.polymorph.utils.TokenTree; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StructureShape; + +import java.nio.file.Path; +import java.util.HashMap; +import java.util.Map; +import java.util.TreeSet; +import java.util.stream.Collectors; + +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.FROM_DAFNY; +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.TO_DAFNY; + +public class AwsSdkShimCodegen { + private final Model model; + private final ServiceShape serviceShape; + private final AwsSdkDotNetNameResolver nameResolver; + private final DafnyNameResolver dafnyNameResolver; + + private static final String IMPL_NAME = "_impl"; + private static final String CONVERT_ERROR_METHOD = "ConvertError"; + + public AwsSdkShimCodegen(final Model model, final ShapeId serviceShapeId) { + this.model = model; + this.serviceShape = model.expectShape(serviceShapeId, ServiceShape.class); + this.nameResolver = new AwsSdkDotNetNameResolver(model, serviceShape); + this.dafnyNameResolver = new DafnyNameResolver(model, serviceShape); + } + + public Map generate() { + final Map codeByPath = new HashMap<>(); + final TokenTree prelude = TokenTree.of( + "using System;", + "using System.IO;", + "using System.Collections.Generic;" + ).lineSeparated(); + + // Service shim + final Path serviceShimPath = Path.of(String.format("%s.cs", nameResolver.shimClassForService())); + final TokenTree serviceShimCode = generateServiceShim(); + codeByPath.put(serviceShimPath, serviceShimCode.prepend(prelude)); + + return codeByPath; + } + + public TokenTree generateServiceShim() { + final TokenTree header = Token.of("internal class %s : %s".formatted( + nameResolver.shimClassForService(), + nameResolver.dafnyTypeForShape(serviceShape.getId()))); + + final TokenTree impl = Token.of("internal %s %s;".formatted(nameResolver.implForServiceClient(), IMPL_NAME)); + final TokenTree constructor = generateServiceShimConstructor(); + final TokenTree operationShims = TokenTree.of(serviceShape.getAllOperations() + .stream() + .map(this::generateOperationShim)).lineSeparated(); + final TokenTree errorTypeShim = generateErrorTypeShim(); + + final TokenTree classBody = TokenTree.of(impl, constructor, operationShims, errorTypeShim).lineSeparated(); + return header + .append(classBody.braced()) + .namespaced(Token.of(nameResolver.namespaceForService())); + } + + public TokenTree generateServiceShimConstructor() { + return Token.of(""" + internal %s(%s impl) { + this.%s = impl; + }""".formatted(nameResolver.shimClassForService(), nameResolver.implForServiceClient(), IMPL_NAME)); + } + + public TokenTree generateOperationShim(final ShapeId operationShapeId) { + final OperationShape operationShape = model.expectShape(operationShapeId, OperationShape.class); + final String dafnyOutputType = nameResolver.dafnyTypeForServiceOperationOutput(operationShape); + final String implOperationName = nameResolver.methodForOperation(operationShapeId) + "Async"; + + final TokenTree sdkRequest = Token.of(operationShape.getInput() + .map(requestShapeId -> "%s sdkRequest = %s(request);".formatted( + nameResolver.baseTypeForShape(requestShapeId), + AwsSdkDotNetNameResolver.qualifiedTypeConverter(requestShapeId, FROM_DAFNY))) + .orElse("")); + + final TokenTree assignSdkResponse = Token.of(operationShape.getOutput() + .map(responseShapeId -> "%s sdkResponse =".formatted(nameResolver.baseTypeForShape(responseShapeId))) + .orElse("")); + + final String requestArg = operationShape.getInput().isPresent() ? "sdkRequest" : ""; + final String blockOnResponse = operationShape.getOutput().isPresent() ? ".Result" : ".Wait()"; + final TokenTree callImpl = Token.of("this.%s.%s(%s)%s;".formatted( + IMPL_NAME, implOperationName, requestArg, blockOnResponse)); + + final TokenTree returnResponse = Token.of(operationShape.getOutput() + .map(responseShapeId -> "return %s.create_Success(%s(sdkResponse));".formatted( + dafnyOutputType, + AwsSdkDotNetNameResolver.qualifiedTypeConverter(responseShapeId, TO_DAFNY))) + .orElse("return %s.create_Success(new %s());".formatted( + dafnyOutputType, nameResolver.dafnyTypeForUnit()))); + + final TokenTree tryBody = TokenTree.of(assignSdkResponse, callImpl, returnResponse).lineSeparated(); + final TokenTree tryBlock = Token.of("try").append(tryBody.braced()); + final TokenTree catchBlock = Token.of(""" + catch (%s ex) { + return %s.create_Failure(this.%s(ex)); + } + """.formatted( + nameResolver.baseExceptionForService(), + dafnyOutputType, + CONVERT_ERROR_METHOD)); + + final TokenTree methodSignature = generateOperationShimSignature(operationShape); + final TokenTree methodBody = TokenTree.of(sdkRequest, tryBlock, catchBlock); + return methodSignature.append(methodBody.braced()); + } + + private TokenTree generateOperationShimSignature(final OperationShape operationShape) { + final String responseType = nameResolver.dafnyTypeForServiceOperationOutput(operationShape); + final String methodName = nameResolver.methodForOperation(operationShape.getId()); + final String requestType = operationShape.getInput() + .map(requestShapeId -> nameResolver.dafnyTypeForShape(requestShapeId) + " request") + .orElse(""); + return Token.of("public %s %s(%s)".formatted(responseType, methodName, requestType)); + } + + /** + * Generates a shim for converting from an AWS SDK-defined exception to the corresponding constructor of the Dafny + * error sum type. + *

+ * We define this here instead of in {@link AwsSdkTypeConversionCodegen} because the error sum type isn't in the + * model; it's only used here in the shims. + */ + public TokenTree generateErrorTypeShim() { + final String dafnyErrorType = nameResolver.dafnyTypeForServiceError(serviceShape); + + // Collect into TreeSet so that we generate code in a deterministic order (lexicographic, in particular) + final TreeSet errorShapes = ModelUtils.streamServiceErrors(model, serviceShape) + .collect(Collectors.toCollection(TreeSet::new)); + final TokenTree convertKnownErrors = TokenTree.of(errorShapes.stream() + .map(errorShape -> { + final ShapeId errorShapeId = errorShape.getId(); + final String sdkErrorType = nameResolver.baseTypeForShape(errorShapeId); + final String dafnyErrorCtor = DotNetNameResolver.dafnyCompiledNameForEnumDefinitionName( + dafnyNameResolver.nameForServiceErrorConstructor(errorShapeId)); + + final String errorConverter = DotNetNameResolver.qualifiedTypeConverter(errorShapeId, TO_DAFNY); + final TokenTree condition = Token.of("if (error is %s)".formatted(sdkErrorType)); + final TokenTree body = Token.of("return %s.create_%s(%s((%s) error));".formatted( + dafnyErrorType, dafnyErrorCtor, errorConverter, sdkErrorType)); + return condition.append(body.braced()); + })).lineSeparated(); + + final String stringConverter = AwsSdkDotNetNameResolver.qualifiedTypeConverter( + ShapeId.from("smithy.api#String"), TO_DAFNY); + final String dafnyUnknownErrorCtor = DotNetNameResolver.dafnyCompiledNameForEnumDefinitionName( + dafnyNameResolver.nameForServiceErrorUnknownConstructor(serviceShape)); + final TokenTree convertUnknownError = Token.of("return %s.create_%s(%s(error.Message));".formatted( + dafnyErrorType, dafnyUnknownErrorCtor, stringConverter)); + + final TokenTree signature = Token.of("private %s %s(%s error)".formatted( + dafnyErrorType, CONVERT_ERROR_METHOD, nameResolver.baseExceptionForService())); + final TokenTree body = TokenTree.of(convertKnownErrors, convertUnknownError).lineSeparated(); + return signature.append(body.braced()); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/AwsSdkTypeConversionCodegen.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/AwsSdkTypeConversionCodegen.java new file mode 100644 index 0000000000..5081c5f505 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/AwsSdkTypeConversionCodegen.java @@ -0,0 +1,115 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import software.amazon.polymorph.utils.Token; +import software.amazon.polymorph.utils.TokenTree; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StringShape; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.ErrorTrait; +import software.amazon.smithy.model.traits.RequiredTrait; + +import java.util.List; +import java.util.Set; + +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.FROM_DAFNY; +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.TO_DAFNY; + +/** + * Generates a {@code TypeConversion} class that includes all {@link TypeConversionCodegen.TypeConverter}s needed + * for AWS SDK-specific types. + */ +public class AwsSdkTypeConversionCodegen extends TypeConversionCodegen { + private static final ShapeId SMITHY_STRING_SHAPE_ID = ShapeId.from("smithy.api#String"); + + public AwsSdkTypeConversionCodegen(final Model model, final ShapeId serviceShapeId) { + super(model, serviceShapeId, + new AwsSdkDotNetNameResolver(model, model.expectShape(serviceShapeId, ServiceShape.class))); + } + + @Override + public Set findShapeIdsToConvert() { + final Set shapeIds = super.findShapeIdsToConvert(); + shapeIds.add(SMITHY_STRING_SHAPE_ID); // needed for converting the message of an unknown error type + return shapeIds; + } + + @Override + public TypeConverter generateStructureConverter(final StructureShape structureShape) { + if (structureShape.hasTrait(ErrorTrait.class)) { + return generateErrorStructureConverter(structureShape); + } + + return super.generateStructureConverter(structureShape); + } + + @Override + protected boolean enumListMembersAreStringsInCSharp() { + return true; + } + + private TypeConverter generateErrorStructureConverter(final StructureShape structureShape) { + // KMS error structures all include a 'message' member and nothing else + // TODO support members other than 'message' + if (!List.of("message").equals(structureShape.getMemberNames())) { + throw new UnsupportedOperationException( + "Error structures must include a 'message' member and no others"); + } + final MemberShape messageMember = structureShape.getMember("message").orElseThrow(); + + // KMS error structures' 'message' member are always optional + // TODO support required 'message' members + if (messageMember.hasTrait(RequiredTrait.class)) { + throw new UnsupportedOperationException("An error structure's 'message' member must be optional"); + } + + final StringShape messageTarget = model.getShape(messageMember.getTarget()) + .flatMap(Shape::asStringShape) + .orElseThrow(() -> new IllegalArgumentException("An error structure's 'message' member must be a string")); + + final TokenTree fromDafnyBody = Token.of(""" + string message = value.message.is_Some ? null : %s(value.message.Extract()); + return new %s(message); + """.formatted( + AwsSdkDotNetNameResolver.typeConverterForShape(messageTarget.getId(), FROM_DAFNY), + nameResolver.baseTypeForShape(structureShape.getId()))); + + final TokenTree toDafnyBody = Token.of(""" + %1$s message = System.String.IsNullOrEmpty(value.Message) + ? %1$s.create_None() + : %1$s.create_Some(%2$s(value.Message)); + return new %3$s(message); + """.formatted( + nameResolver.dafnyTypeForShape(messageMember.getId()), + AwsSdkDotNetNameResolver.typeConverterForShape(messageTarget.getId(), TO_DAFNY), + nameResolver.dafnyTypeForShape(structureShape.getId()))); + + return buildConverterFromMethodBodies(structureShape, fromDafnyBody, toDafnyBody); + } + + TypeConverter generateAwsSdkServiceReferenceStructureConverter(final StructureShape structureShape) { + final String sdkServiceImpl = ((AwsSdkDotNetNameResolver) nameResolver).implForServiceClient(); + final String serviceClientShim = "%s.%s".formatted( + nameResolver.namespaceForService(), + ((AwsSdkDotNetNameResolver) nameResolver).shimClassForService()); + final String serviceInterfaceType = nameResolver.baseTypeForShape(serviceShape.getId()); + + final String throwCustomImplException = + "throw new System.ArgumentException(\"Custom implementations of %s are not supported yet\");" + .formatted(serviceInterfaceType); + final TokenTree fromDafnyBody = Token.of( + "if (value is %s shim) { return shim._impl; }".formatted(serviceClientShim), + throwCustomImplException); + final TokenTree toDafnyBody = TokenTree.of( + "if (value is %s impl) { return new %s(impl); }".formatted(sdkServiceImpl, serviceClientShim), + throwCustomImplException); + + return buildConverterFromMethodBodies(structureShape, fromDafnyBody, toDafnyBody); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/DotNetNameResolver.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/DotNetNameResolver.java new file mode 100644 index 0000000000..89ae022aee --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/DotNetNameResolver.java @@ -0,0 +1,569 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Joiner; +import com.google.common.base.Splitter; +import software.amazon.polymorph.smithydafny.DafnyNameResolver; +import software.amazon.polymorph.utils.ModelUtils; +import software.amazon.polymorph.traits.DafnyUtf8BytesTrait; +import software.amazon.polymorph.traits.PositionalTrait; +import software.amazon.polymorph.traits.ReferenceTrait; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.ListShape; +import software.amazon.smithy.model.shapes.MapShape; +import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ResourceShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.ShapeType; +import software.amazon.smithy.model.shapes.StringShape; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.EnumTrait; +import software.amazon.smithy.utils.StringUtils; + +import javax.annotation.Nullable; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Stream; + +/** + * Provides a consistent mapping between names of model Shapes and generated identifiers. + */ +public class DotNetNameResolver { + private final Model model; + private final ServiceShape serviceShape; + + public DotNetNameResolver(Model model, ServiceShape serviceShape) { + this.model = model; + this.serviceShape = serviceShape; + } + + private static final Set C_SHARP_BUILT_IN_VALUE_TYPES = Set.of( + // integral numeric types + "sbyte", "byte", "short", "ushort", "int", "uint", "long", "ulong", "nint", "nuint", + // floating-point numeric types + "float", "double", "decimal", + // other primitives + "bool", "char", + // other non-primitive value types + "System.DateTime" + ); + + public static final String TYPE_CONVERSION_CLASS_NAME = "TypeConversion"; + + /** + * Returns the C# namespace containing the C# implementation/interface for the given shape ID. + */ + public String namespaceForShapeId(final ShapeId shapeId) { + Stream parts = Splitter.on('.') + .splitToList(shapeId.getNamespace()) + .stream() + .map(StringUtils::capitalize); + return Joiner.on('.').join(parts.iterator()); + } + + public String namespaceForService() { + return namespaceForShapeId(serviceShape.getId()); + } + + public String clientForService() { + return serviceShape.getId().getName(serviceShape) + "Client"; + } + + public String baseClientForService() { + return clientForService() + "Base"; + } + + public String interfaceForService() { + return interfaceForService(serviceShape.getId()); + } + + public String interfaceForService(final ShapeId serviceShapeId) { + return "I" + serviceShapeId.getName(serviceShape); + } + + public String methodForOperation(final ShapeId operationShapeId) { + return model.expectShape(operationShapeId, OperationShape.class).getId().getName(serviceShape); + } + + public String abstractMethodForOperation(final ShapeId operationShapeId) { + return String.format("_%s", methodForOperation(operationShapeId)); + } + + /** + * Returns the name of the class generated for the given structure shape. Note that this method is only valid for + * structure shapes that will have a corresponding generated class. + */ + public String classForStructure(final ShapeId structureShapeId) { + final StructureShape structureShape = model.expectShape(structureShapeId, StructureShape.class); + + // Sanity check that we aren't using this method for non-generated structures + assert !structureShape.hasTrait(ReferenceTrait.class); + assert !structureShape.hasTrait(PositionalTrait.class); + + return model.expectShape(structureShapeId, StructureShape.class).getId().getName(serviceShape); + } + + private static final Map NATIVE_TYPES_BY_SMITHY_PRELUDE_SHAPE_NAME; + private static final Map NATIVE_TYPES_BY_SIMPLE_SHAPE_TYPE; + static { + NATIVE_TYPES_BY_SMITHY_PRELUDE_SHAPE_NAME = Map.ofEntries( + Map.entry("String", "string"), + Map.entry("Blob", "System.IO.MemoryStream"), + Map.entry("Boolean", "bool"), + Map.entry("PrimitiveBoolean", "bool"), + Map.entry("Byte", "sbyte"), + Map.entry("PrimitiveByte", "sbyte"), + Map.entry("Short", "short"), + Map.entry("PrimitiveShort", "short"), + Map.entry("Integer", "int"), + Map.entry("PrimitiveInteger", "int"), + Map.entry("Long", "long"), + Map.entry("PrimitiveLong", "long"), + Map.entry("Float", "float"), + Map.entry("PrimitiveFloat", "float"), + Map.entry("Double", "double"), + Map.entry("PrimitiveDouble", "double"), + Map.entry("Timestamp", "System.DateTime") + ); + NATIVE_TYPES_BY_SIMPLE_SHAPE_TYPE = Map.ofEntries( + Map.entry(ShapeType.BLOB, "System.IO.MemoryStream"), + Map.entry(ShapeType.BOOLEAN, "bool"), + Map.entry(ShapeType.STRING, "string"), + Map.entry(ShapeType.BYTE, "sbyte"), + Map.entry(ShapeType.SHORT, "short"), + Map.entry(ShapeType.INTEGER, "int"), + Map.entry(ShapeType.LONG, "long"), + Map.entry(ShapeType.FLOAT, "float"), + Map.entry(ShapeType.DOUBLE, "double"), + Map.entry(ShapeType.TIMESTAMP, "System.DateTime") + ); + } + + /** + * Returns the C# type used to store values of the given member shape within a structure class. + * + * This is always nullable, so it can represent uninitialized values. + */ + public String classFieldTypeForStructureMember(final MemberShape memberShape) { + return nullableTypeForStructureMember(memberShape); + } + + /** + * Returns the C# type used to expose values of the given member shape as a property of its structure class. + * + * This is always non-nullable. + */ + public String classPropertyTypeForStructureMember(final MemberShape memberShape) { + return baseTypeForShape(memberShape.getTarget()); + } + + protected String baseTypeForString(final StringShape stringShape) { + final ShapeId shapeId = stringShape.getId(); + final String namespace = namespaceForShapeId(shapeId); + return stringShape.hasTrait(EnumTrait.class) + ? "%s.%s".formatted(namespace, classForEnum(shapeId)) + : "string"; + } + + protected String baseTypeForList(final ListShape listShape) { + return "System.Collections.Generic.List<%s>".formatted(baseTypeForMember(listShape.getMember())); + } + + protected String baseTypeForMap(final MapShape mapShape) { + return "System.Collections.Generic.Dictionary<%s, %s>".formatted( + baseTypeForMember(mapShape.getKey()), + baseTypeForMember(mapShape.getValue())); + } + + protected String baseTypeForStructure(final StructureShape structureShape) { + // The base type of a reference structure is the base trait for its referent + final Optional referenceTraitOptional = structureShape.getTrait(ReferenceTrait.class); + if (referenceTraitOptional.isPresent()) { + final ReferenceTrait referenceTrait = referenceTraitOptional.get(); + final ShapeId referentShapeId = referenceTrait.getReferentId(); + if (model.getShape(referentShapeId).isEmpty()) { + // TODO: support external referents + throw new IllegalStateException("Structure %s has external referent %s, this is unsupported" + .formatted(structureShape.getId(), referentShapeId)); + } + return baseTypeForShape(referentShapeId); + } + + // The base type of a positional structure is the base type of its sole member + final Optional positionalMember = ModelUtils.getPositionalStructureMember(structureShape); + if (positionalMember.isPresent()) { + return baseTypeForShape(positionalMember.get()); + } + + // The base type of any other structure is the name of the corresponding generated class + final String structureNamespace = namespaceForShapeId(structureShape.getId()); + return "%s.%s".formatted(structureNamespace, classForStructure(structureShape.getId())); + } + + protected String baseTypeForMember(final MemberShape memberShape) { + final String baseType = baseTypeForShape(memberShape.getTarget()); + final boolean isOptional = memberShapeIsOptional(memberShape); + return isOptional ? baseTypeForOptionalMember(memberShape) : baseType; + } + + protected String baseTypeForOptionalMember(final MemberShape memberShape) { + final String baseType = baseTypeForShape(memberShape.getTarget()); + // We annotate C# value types with `?` to make them nullable. + // We cannot do the same for C# reference types since those types are already nullable by design. + // TODO: nullable reference types appear to be supported in C# 8.0+. Maybe revisit this. + // https://issues.amazon.com/issues/CrypTool-4156 + return isValueType(memberShape.getTarget()) ? baseType + "?" : baseType; + } + + protected String baseTypeForService(final ServiceShape serviceShape) { + final ShapeId shapeId = serviceShape.getId(); + + // TODO better way to determine if AWS SDK + if (shapeId.getNamespace().startsWith("com.amazonaws.")) { + return new AwsSdkDotNetNameResolver(model, serviceShape).baseTypeForService(serviceShape); + } + + return "%s.%s".formatted( + namespaceForShapeId(shapeId), interfaceForService(shapeId)); + } + + protected String baseTypeForResource(final ResourceShape resourceShape) { + final ShapeId shapeId = resourceShape.getId(); + return "%s.%s".formatted( + namespaceForShapeId(shapeId), interfaceForResource(shapeId)); + } + + public boolean isValueType(final ShapeId shapeId) { + final String baseType = baseTypeForShape(shapeId); + return C_SHARP_BUILT_IN_VALUE_TYPES.contains(baseType); + } + + @SuppressWarnings("OptionalGetWithoutIsPresent") + public String baseTypeForShape(final ShapeId shapeId) { + final Shape shape = model.expectShape(shapeId); + + // First check if this is a built-in Smithy shape. If so, we just map it to the native type and return + if (ModelUtils.isSmithyApiShape(shapeId)) { + @Nullable final String nativeTypeName = NATIVE_TYPES_BY_SMITHY_PRELUDE_SHAPE_NAME.get(shapeId.getName(serviceShape)); + return Objects.requireNonNull(nativeTypeName, + () -> String.format("No native type for prelude shape %s", shapeId)); + } + + return switch (shape.getType()) { + // For supported simple shapes, just map to native types + case BLOB, BOOLEAN, INTEGER, LONG, TIMESTAMP -> { + @Nullable final String nativeTypeName = NATIVE_TYPES_BY_SIMPLE_SHAPE_TYPE.get(shape.getType()); + yield Objects.requireNonNull(nativeTypeName, + () -> String.format("No native type for shape type %s", shape.getType())); + } + + case STRING -> baseTypeForString(shape.asStringShape().get()); + case LIST -> baseTypeForList(shape.asListShape().get()); + case MAP -> baseTypeForMap(shape.asMapShape().get()); + case STRUCTURE -> baseTypeForStructure(shape.asStructureShape().get()); + case MEMBER -> baseTypeForMember(shape.asMemberShape().get()); + case SERVICE -> baseTypeForService(shape.asServiceShape().get()); + case RESOURCE -> baseTypeForResource(shape.asResourceShape().get()); + + default -> throw new UnsupportedOperationException("Shape %s has unsupported type %s" + .formatted(shapeId, shape.getType())); + }; + } + + private String nullableTypeForStructureMember(final MemberShape memberShape) { + return baseTypeForOptionalMember(memberShape); + } + + /** + * Returns the name of the (private) structure class field for the given member shape. + */ + public String classFieldForStructureMember(final MemberShape memberShape) { + return "_%s".formatted(StringUtils.uncapitalize(memberShape.getMemberName())); + } + + /** + * Returns the name of the (public) structure class property for the given member shape. + */ + public String classPropertyForStructureMember(final MemberShape memberShape) { + return StringUtils.capitalize(memberShape.getMemberName()); + } + + public String interfaceForResource(final ShapeId resourceShapeId) { + return String.format("I%s", StringUtils.capitalize(resourceShapeId.getName(serviceShape))); + } + + public String baseClassForResource(final ShapeId resourceShapeId) { + return String.format("%sBase", StringUtils.capitalize(resourceShapeId.getName(serviceShape))); + } + + public String shimClassForResource(final ShapeId resourceShapeId) { + return StringUtils.capitalize(resourceShapeId.getName(serviceShape)); + } + + public String classForEnum(final ShapeId enumShapeId) { + return StringUtils.capitalize(enumShapeId.getName(serviceShape)); + } + + /** + * Implements {@code DafnyAst.NonglobalVariable.CompilerizeName} for strings which are valid enum definition names + * according to {@link ModelUtils#isValidEnumDefinitionName(String)}. + * + * @see CompilerizeName + */ + public static String dafnyCompiledNameForEnumDefinitionName(final String name) { + if (!ModelUtils.isValidEnumDefinitionName(name)) { + throw new IllegalArgumentException("The enum definition name '%s' is forbidden".formatted(name)); + } + + // We only allow uppercase ASCII letters and underscores in enum definition names, so it suffices to replace + // each underscore with two underscores. + return name.replace("_", "__"); + } + + /** + * Returns a unique type converter method name for the given shape and type conversion direction. + *

+ * This is necessary because all type converter methods for a given model will coexist in a single class. There is a + * one-to-one mapping between shapes used in the model and type converters in the class, so the function that names + * converter methods must also be one-to-one. + */ + public static String typeConverterForShape(final ShapeId shapeId, final TypeConversionDirection direction) { + final String directionStr = switch (direction) { + case TO_DAFNY -> "ToDafny"; + case FROM_DAFNY -> "FromDafny"; + }; + final String encodedShapeId = encodedIdentForShapeId(shapeId); + return String.format("%s_%s", directionStr, encodedShapeId); + } + + /** + * Returns the converter method name for the given shape and type conversion direction, qualified with the type + * conversion class name. + */ + public static String qualifiedTypeConverter(final ShapeId shapeId, final TypeConversionDirection direction) { + final String methodName = DotNetNameResolver.typeConverterForShape(shapeId, direction); + return "%s.%s".formatted(DotNetNameResolver.TYPE_CONVERSION_CLASS_NAME, methodName); + } + + /** + * Returns the abstract Dafny-compiled-C# type corresponding to the given shape, or the concrete type if no such + * abstract type exists. For example, a list shape is a {@code Dafny.ISequence} rather than a + * {@code Dafny.Sequence}, but an integer shape is simply an {@code int}. + *

+ * Note that this method is mutually recursive with the "dafnyTypeForA" methods (for aggregate shape types A), but + * termination is guaranteed. This is because the Smithy specification requires that if an aggregate shape has a + * path to itself (by recursively traversing through members and their targets), then the path must include a + * structure or union shape (which have no type variables). The core Smithy validation logic takes responsibility to + * ensure this. + */ + @SuppressWarnings("OptionalGetWithoutIsPresent") + public String dafnyTypeForShape(final ShapeId shapeId) { + final Shape shape = model.getShape(shapeId) + .orElseThrow(() -> new IllegalStateException("Cannot find shape " + shapeId)); + + return switch (shape.getType()) { + case BLOB -> "Dafny.ISequence"; + case BOOLEAN -> "bool"; + case STRING -> dafnyTypeForString(shape.asStringShape().get()); + case INTEGER -> "int"; + case LONG -> "long"; + // TODO create/use better timestamp type in Dafny libraries + case TIMESTAMP -> "Dafny.ISequence"; + case LIST -> dafnyTypeForList(shape.asListShape().get()); + case MAP -> dafnyTypeForMap(shape.asMapShape().get()); + case STRUCTURE -> dafnyTypeForStructure(shape.asStructureShape().get()); + case MEMBER -> dafnyTypeForMember(shape.asMemberShape().get()); + case SERVICE -> dafnyTypeForService(shape.asServiceShape().get()); + case RESOURCE -> dafnyTypeForResource(shape.asResourceShape().get()); + default -> throw new UnsupportedOperationException("Unsupported shape " + shapeId); + }; + } + + // We explicitly specify the Dafny namespace just in case of collisions. + private String dafnyTypeForShapeWithExplicitDatatype(final ShapeId shapeId) { + return "%s.%s".formatted(DafnyNameResolver.dafnyExternNamespaceForShapeId(shapeId), shapeId.getName(serviceShape)); + } + + private String dafnyTypeForString(final StringShape stringShape) { + final ShapeId shapeId = stringShape.getId(); + if (stringShape.hasTrait(EnumTrait.class)) { + return dafnyTypeForShapeWithExplicitDatatype(shapeId); + } + if (stringShape.hasTrait(DafnyUtf8BytesTrait.class)) { + return "Dafny.ISequence"; + } + return "Dafny.ISequence"; + } + + private String dafnyTypeForList(final ListShape listShape) { + return "Dafny.ISequence<%s>".formatted(dafnyTypeForMember(listShape.getMember())); + } + + private String dafnyTypeForMap(final MapShape mapShape) { + return "Dafny.IMap<%s, %s>".formatted( + dafnyTypeForMember(mapShape.getKey()), + dafnyTypeForMember(mapShape.getValue())); + } + + private String dafnyTypeForStructure(final StructureShape structureShape) { + // The Dafny type of a reference structure is the Dafny trait for its referent + final Optional referenceTrait = structureShape.getTrait(ReferenceTrait.class); + if (referenceTrait.isPresent()) { + return dafnyTypeForShape(referenceTrait.get().getReferentId()); + } + + // The Dafny type of a positional structure is the Dafny type of its sole member + final Optional positionalMember = ModelUtils.getPositionalStructureMember(structureShape); + if (positionalMember.isPresent()) { + return dafnyTypeForShape(positionalMember.get()); + } + + // The Dafny type of other structures is simply the structure's name. + return dafnyTypeForShapeWithExplicitDatatype(structureShape.getId()); + } + + private String dafnyTypeForMember(final MemberShape memberShape) { + final String baseType = dafnyTypeForShape(memberShape.getTarget()); + final boolean isOptional = memberShapeIsOptional(memberShape); + + // Entity references are represented as Dafny traits, and Dafny traits can't be type parameters. So in the + // Dafny implementation of the model, an optional entity reference member is represented as a nullable type T? + // instead of an Optional. This works around the limitation. + // TODO: remove workaround when https://github.com/dafny-lang/dafny/issues/1499 is resolved + if (isOptional && !ModelUtils.memberShapeTargetsEntityReference(model, memberShape)) { + return "Wrappers_Compile.Option<%s>".formatted(baseType); + } + return baseType; + } + + private String dafnyTypeForService(final ServiceShape serviceShape) { + final ShapeId serviceShapeId = serviceShape.getId(); + return "%s.%sClient".formatted(DafnyNameResolver.dafnyExternNamespaceForShapeId(serviceShapeId), interfaceForService(serviceShapeId)); + } + + private String dafnyTypeForResource(final ResourceShape resourceShape) { + final ShapeId resourceShapeId = resourceShape.getId(); + return "%s.%s".formatted(DafnyNameResolver.dafnyExternNamespaceForShapeId(resourceShapeId), interfaceForResource(resourceShapeId)); + } + + public String dafnyTypeForServiceError(final ServiceShape serviceShape) { + return "%s.%sError".formatted( + DafnyNameResolver.dafnyExternNamespaceForShapeId(serviceShape.getId()), + serviceShape.getContextualName(serviceShape)); + } + + /** + * Returns the compiled-Dafny return type for an operation of this service. + * If the operation has no associated errors... + *

    + *
  • ... and the operation has output, this is the corresponding compiled-Dafny output type.
    • + *
  • ... and the operation has no output, this is the compiled-Dafny {@code ()} ("unit").
    • + *
+ * Otherwise, if the operation does have associated errors, + * then the this is the compiled-Dafny {@code Result}, + * where {@code T} is either {@code ()} or the corresponding Dafny-compiled output type, + * as determined above. + */ + public String dafnyTypeForServiceOperationOutput(final OperationShape operationShape) { + final String outputType = operationShape.getOutput() + .map(this::dafnyTypeForShape) + .orElse(dafnyTypeForUnit()); + return operationShape.getErrors().isEmpty() + ? outputType + : "Wrappers_Compile.Result<%s, %s>".formatted(outputType, dafnyTypeForServiceError(serviceShape)); + }; + + public String dafnyTypeForUnit() { + return "_System.Tuple0"; + } + + /** + * Returns the name of the compiled-Dafny implementation of the service client. + * + * Note that the service client lives in a sub-namespace of the same name. This is because the generated Dafny API + * skeleton uses the plain "Dafny.(service namespace)" namespace, and implementations cannot use the same extern + * namespace. + * + * FIXME: remove this workaround once Dafny allows duplicate extern namespaces + */ + public String dafnyImplForServiceClient() { + return "%1$s.%2$s.%2$s".formatted(DafnyNameResolver.dafnyExternNamespaceForShapeId(serviceShape.getId()), clientForService()); + } + + public boolean memberShapeIsOptional(final MemberShape memberShape) { + return ModelUtils.memberShapeIsOptional(model, memberShape); + } + + /** + * Encodes a shape ID as a unique valid C# identifier. + *

+ * The encoding of a shape ID consists of type-length-value encodings of each of its "parts", separated by two + * underscores. For example, "foo.bar#Shape$Member" is encoded as N3_foo__N3_bar__S5_Shape__M6_Member. + *

+ * The encoding scheme has some redundancy in order to aid legibility of encoded "normal" shape IDs, such as the + * redundant double-underscore between "parts". But even an inscrutable encoding (arising from a pathological shape + * ID) has a unique parse, so there is no concern for an encoding collision. + *

+ * (Note: we never need to actually parse this identifier.) + */ + @VisibleForTesting + public static String encodedIdentForShapeId(final ShapeId shapeId) { + final String namespace = shapeId.getNamespace(); + final String relativeShape = shapeId.getName(); + final Optional memberOptional = shapeId.getMember(); + + // "N" for namespace + final List encodedParts = new ArrayList<>(); + for (final String namespacePart : namespace.split("\\.")) { + encodedParts.add(String.format("N%d_%s", namespacePart.length(), namespacePart)); + } + // "S" for relative shape + encodedParts.add(String.format("S%d_%s", relativeShape.length(), relativeShape)); + // "M" for member + if (memberOptional.isPresent()) { + final String member = memberOptional.get(); + encodedParts.add(String.format("M%d_%s", member.length(), member)); + } + + return Joiner.on("__").join(encodedParts); + } + + public Model getModel() { + return model; + } + + public ServiceShape getServiceShape() { + return serviceShape; + } + + @Override + public boolean equals(Object obj) { + if (obj == this) return true; + if (obj == null || obj.getClass() != this.getClass()) return false; + var that = (DotNetNameResolver) obj; + return Objects.equals(this.model, that.model) && + Objects.equals(this.serviceShape, that.serviceShape); + } + + @Override + public int hashCode() { + return Objects.hash(model, serviceShape); + } + + @Override + public String toString() { + return "CSharpNameResolver[" + + "model=" + model + ", " + + "serviceShape=" + serviceShape + ']'; + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/ServiceCodegen.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/ServiceCodegen.java new file mode 100644 index 0000000000..1760809ab1 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/ServiceCodegen.java @@ -0,0 +1,514 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import com.google.common.annotations.VisibleForTesting; +import software.amazon.polymorph.utils.ModelUtils; +import software.amazon.polymorph.traits.ClientConfigTrait; +import software.amazon.polymorph.traits.PositionalTrait; +import software.amazon.polymorph.traits.ReferenceTrait; +import software.amazon.polymorph.utils.Token; +import software.amazon.polymorph.utils.TokenTree; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.EntityShape; +import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ResourceShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StringShape; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.EnumDefinition; +import software.amazon.smithy.model.traits.EnumTrait; +import software.amazon.smithy.model.traits.TraitDefinition; + +import java.nio.file.Path; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.stream.Stream; + +/** + * Codegen for a service's API skeleton (service interface and structures). + * + * Note: this code generator does not aim to generate "nicely-formatted" code. That responsibility is left to external code formatters. + */ +public class ServiceCodegen { + private final Model model; + private final ServiceShape serviceShape; + private final DotNetNameResolver nameResolver; + + public ServiceCodegen(final Model model, final ShapeId serviceShapeId) { + this.model = model; + + this.serviceShape = model.expectShape(serviceShapeId, ServiceShape.class); + this.nameResolver = new DotNetNameResolver(model, serviceShape); + } + + /** + * @return map of skeleton's file paths to generated ASTs + */ + public Map generate() { + final Map codeByPath = new HashMap<>(); + final TokenTree prelude = TokenTree.of( + "using System;", + // Conditional imports. + // TODO: not all files will need these, and some of them result in duplicates (e.g. Aws.Crypto + // must be imported in the Esdk module, but is obviously not necessary in the Crypto module). + // Get smarter about generating imports. + "using Aws.Crypto;", + // end conditional imports + "using", + nameResolver.namespaceForService(), + ";" + ).lineSeparated(); + + // Service interface + final Path serviceInterfacePath = Path.of(String.format("%s.cs", nameResolver.interfaceForService())); + final TokenTree serviceInterfaceCode = generateServiceInterface(); + codeByPath.put(serviceInterfacePath, serviceInterfaceCode.prepend(prelude)); + + // Service client base + final Path serviceClientBasePath = Path.of(String.format("%s.cs", nameResolver.baseClientForService())); + final TokenTree serviceClientBaseCode = generateServiceClientBase(serviceShape); + codeByPath.put(serviceClientBasePath, serviceClientBaseCode.prepend(prelude)); + + // Structures + model.getStructureShapes() + .stream() + .filter(this::shouldGenerateStructure) + .filter(shape -> ModelUtils.isInServiceNamespace(shape.getId(), serviceShape)) + .forEach(shape -> { + final Path structureClassPath = Path.of(String.format("%s.cs", nameResolver.classForStructure(shape.getId()))); + final TokenTree structureCode = generateStructureClass(shape); + codeByPath.put(structureClassPath, structureCode.prepend(prelude)); + }); + + // Enums + model.getStringShapesWithTrait(EnumTrait.class) + .stream() + .map(Shape::getId) + .filter(enumShapeId -> ModelUtils.isInServiceNamespace(enumShapeId, serviceShape)) + .forEach(enumShapeId -> { + final Path enumClassPath = Path.of(String.format("%s.cs", nameResolver.classForEnum(enumShapeId))); + final TokenTree enumCode = generateEnumClass(enumShapeId); + codeByPath.put(enumClassPath, enumCode.prepend(prelude)); + }); + + // Resources + model.getResourceShapes() + .stream() + .map(ResourceShape::getId) + .filter(resourceShapeId -> ModelUtils.isInServiceNamespace(resourceShapeId, serviceShape)) + .forEach(resourceShapeId -> { + final Path resourceInterfacePath = Path.of(String.format("%s.cs", nameResolver.interfaceForResource(resourceShapeId))); + final TokenTree resourceInterface = generateResourceInterface(resourceShapeId); + codeByPath.put(resourceInterfacePath, resourceInterface.prepend(prelude)); + + final Path resourceClassPath = Path.of(String.format("%s.cs", nameResolver.baseClassForResource(resourceShapeId))); + final TokenTree resourceClass = generateResourceClass(resourceShapeId); + codeByPath.put(resourceClassPath, resourceClass.prepend(prelude)); + }); + + return codeByPath; + } + + @VisibleForTesting + boolean shouldGenerateStructure(final StructureShape structureShape) { + return + // Traits are structures, but aren't needed outside Smithy + !structureShape.hasTrait(TraitDefinition.class) + // References are transparent in C#, so we don't need to generate a class for them + && !structureShape.hasTrait(ReferenceTrait.class) + // Structures marked with positional are intended to be unwrapped, so we don't need + // to generate the wrapper structure + && !structureShape.hasTrait(PositionalTrait.class); + } + + /** + * Generates the interface (skeleton) for a service shape, which includes a method stub for each of its operations. + */ + public TokenTree generateServiceInterface() { + final TokenTree methodsTokens = TokenTree.of(serviceShape.getOperations() + .stream() + .map(this::generateInterfaceMethod)) + .lineSeparated(); + final TokenTree interfaceTokens = TokenTree.of( + Token.of("public interface"), + Token.of(nameResolver.interfaceForService()), + methodsTokens.braced() + ); + return interfaceTokens.namespaced(Token.of(nameResolver.namespaceForService())); + } + + /** + * Generates the config field and constructor for our base client classes. + */ + public TokenTree generateClientConstructor(final ServiceShape serviceShape) { + final Optional configTraitOptional = serviceShape.getTrait(ClientConfigTrait.class); + + final String configFieldName = "Config"; + final Optional configTypeOptional = configTraitOptional + .map(ClientConfigTrait::getClientConfigId) + .map(nameResolver::baseTypeForShape); + + final TokenTree configFieldVariable = configTypeOptional + .map(configType -> TokenTree.of("public", configType, configFieldName, "{ get; private set; }")) + .orElse(TokenTree.empty()); + + final TokenTree constructorParams = configTypeOptional + .map(configType -> TokenTree.of(configType, configFieldName)) + .orElse(TokenTree.empty()); + final TokenTree constructorSignature = TokenTree + .of("protected", nameResolver.baseClientForService()) + .append(constructorParams.parenthesized()); + + final TokenTree constructorBody; + if (!configTraitOptional.isPresent()) { + constructorBody = TokenTree.empty(); + } else { + constructorBody = TokenTree.of( + "this." + configFieldName, + "=", + configFieldName, + ";"); + } + + return TokenTree.of( + configFieldVariable, + constructorSignature, + constructorBody.braced() + ).lineSeparated(); + } + + /** + * Generates the abstract client base class for the service + */ + public TokenTree generateServiceClientBase(final ServiceShape serviceShape) { + final TokenTree constructor = generateClientConstructor(serviceShape); + final TokenTree operationBody = generateEntityClassBody(serviceShape.toShapeId()); + + final TokenTree completeBody = TokenTree.of(constructor, operationBody).lineSeparated().braced(); + + final TokenTree classDeclaration = TokenTree.of( + "public abstract class", + nameResolver.baseClientForService(), + ":", + nameResolver.interfaceForService() + ); + + return classDeclaration + .append(completeBody) + .namespaced(Token.of(nameResolver.namespaceForService())); + } + + /** + * Generates the signature of a method + * e.g. EncryptOutput Encrypt ( EncryptInput input ) + * Extracted into its own method because we want to generate this both for the interface and for the base class + * + * NOTE: The return has no modifiers or access level. If callers need to set a method as public/protected/etc, + * they are responsible for doing so. + */ + public TokenTree generateOperationSignature(final ShapeId operationShapeId) { + final OperationShape operationShape = model.expectShape(operationShapeId, OperationShape.class); + + final TokenTree outputType = generateOperationReturnType(operationShape); + final TokenTree paramTokens = generateOperationParameter(operationShape); + + return TokenTree.of( + outputType, + Token.of(nameResolver.methodForOperation(operationShapeId)), + paramTokens.parenthesized() + ); + + } + + public TokenTree generateInterfaceMethod(final ShapeId operationShapeId) { + // For interfaces (which don't have bodies for operations), we just take the basic operation + // and end the statement with a ';' + return TokenTree.of( + generateOperationSignature(operationShapeId), + Token.of(';') + ); + } + + /** + * @return a data class for the given structure shape + */ + public TokenTree generateStructureClass(final StructureShape structureShape) { + final Token structureClassName = Token.of(nameResolver.classForStructure(structureShape.getId())); + + final TokenTree fields = TokenTree.of(ModelUtils.streamStructureMembers(structureShape) + .map(this::generateStructureClassField)).lineSeparated(); + final TokenTree properties = TokenTree.of(ModelUtils.streamStructureMembers(structureShape) + .map(this::generateStructureClassProperty)).lineSeparated(); + + // This is a no-op for now, because the only constraint trait we're currently using is @required, and that's + // checked upon construction (in the corresponding Builder). + // TODO: support other constraint traits as needed + final TokenTree validateMethod = Token.of("public void Validate() {}"); + + final TokenTree bodyTokens = TokenTree.of(fields, properties, validateMethod).lineSeparated().braced(); + + final TokenTree namespace = Token.of(nameResolver.namespaceForService()); + return TokenTree.of(Token.of("public class"), structureClassName, bodyTokens).namespaced(namespace); + } + + /** + * @return field declaration for the given structure member + */ + public TokenTree generateStructureClassField(final MemberShape memberShape) { + final TokenTree typeToken = Token.of(nameResolver.classFieldTypeForStructureMember(memberShape)); + return TokenTree.of( + Token.of("private"), + typeToken, + Token.of(nameResolver.classFieldForStructureMember(memberShape)), + Token.of(';')); + } + + /** + * @return property for the given structure member, with a getter and setter + */ + public TokenTree generateStructureClassProperty(final MemberShape memberShape) { + final String fieldName = nameResolver.classFieldForStructureMember(memberShape); + + // Class fields are always nullable, so we need to provide a default value for value types + final boolean isValueType = nameResolver.isValueType(memberShape.getTarget()); + final String unwrapValue = isValueType ? ".GetValueOrDefault()" : ""; + + final TokenTree getter = Token.of("get { return this.%s%s; }".formatted(fieldName, unwrapValue)); + final TokenTree setter = Token.of("set { this.%s = value; }".formatted(fieldName)); + + final String type = nameResolver.classPropertyTypeForStructureMember(memberShape); + final String propertyName = nameResolver.classPropertyForStructureMember(memberShape); + final TokenTree body = TokenTree.of(getter, setter).lineSeparated(); + return TokenTree.of("public", type, propertyName).append(body.braced()); + } + + public TokenTree generateResourceInterface(final ShapeId resourceShapeId) { + final ResourceShape resourceShape = model.expectShape(resourceShapeId, ResourceShape.class); + + final TokenTree bodyTokens = TokenTree.of( + resourceShape.getOperations().stream().map( + operationShapeId -> generateInterfaceMethod(operationShapeId) + )).lineSeparated(); + + return TokenTree.of( + Token.of("public interface"), + Token.of(nameResolver.interfaceForResource(resourceShapeId)), + bodyTokens.braced() + ).namespaced(Token.of(nameResolver.namespaceForService())); + } + + /** + * Takes a resource or service shape and generates the body of an abstract base class which implements operations + * and declares abstract operations which should be overridden. + * + * @param entityShapeId The id of the service or resource shape + * @return A token tree with the class body + */ + public TokenTree generateEntityClassBody(final ShapeId entityShapeId) { + final EntityShape entityShape = model.expectShape(entityShapeId, EntityShape.class); + + final TokenTree bodyTokens = TokenTree.of(entityShape.getOperations().stream().map(operationShapeId -> { + final OperationShape operationShape = model.expectShape(operationShapeId, OperationShape.class); + + final TokenTree concreteMethodSignature = TokenTree.of( + TokenTree.of("public"), + generateOperationSignature(operationShapeId) + ); + + final TokenTree returnType = generateOperationReturnType(operationShape); + final TokenTree param = generateOperationParameter(operationShape); + final Token abstractMethodName = Token.of(nameResolver.abstractMethodForOperation(operationShapeId)); + + final Token validate = Token.of(operationShape.getInput().isPresent() ? "input.Validate();" : ""); + final Token abstractArg = Token.of(operationShape.getInput().isPresent() ? "input" : ""); + final Token returnOrBlank = Token.of(operationShape.getOutput().isPresent() ? "return" : ""); + final TokenTree concreteMethodBody = TokenTree.of( + validate, + returnOrBlank, abstractMethodName, abstractArg.parenthesized(), Token.of(';') + ).braced(); + + final TokenTree abstractMethodSignature = TokenTree.of( + Token.of("protected abstract"), + returnType, + abstractMethodName, + param.parenthesized(), + Token.of(';') + ); + + return TokenTree.of(concreteMethodSignature, concreteMethodBody, abstractMethodSignature).lineSeparated(); + })).lineSeparated(); + + return bodyTokens; + } + + public TokenTree generateResourceClass(final ShapeId resourceShapeId) { + final TokenTree bodyTokens = generateEntityClassBody(resourceShapeId); + + final TokenTree classDeclaration = TokenTree.of( + "public abstract class", + nameResolver.baseClassForResource(resourceShapeId), + ":", + nameResolver.interfaceForResource(resourceShapeId) + ); + return classDeclaration + .append(bodyTokens.braced()) + .namespaced(Token.of(nameResolver.namespaceForService())); + } + + /** + * @return either "OperationInput input" if the given operation shape has input OperationInput, or "" otherwise + */ + public TokenTree generateOperationParameter(final OperationShape operationShape) { + return operationShape.getInput() + .map(inputShapeId -> TokenTree.of(nameResolver.baseTypeForShape(inputShapeId), "input")) + .orElse(TokenTree.empty()); + } + + /** + * @return either "OperationOutput" if the given operation shape has output OperationOutput, or "void" otherwise + */ + public TokenTree generateOperationReturnType(final OperationShape operationShape) { + return operationShape.getOutput() + .map(outputShapeId -> Token.of(nameResolver.baseTypeForShape(outputShapeId))) + .orElse(Token.of("void")); + } + + private EnumTrait getAndValidateEnumTrait(final StringShape stringShape) { + final EnumTrait enumTrait = stringShape.getTrait(EnumTrait.class) + .orElseThrow(() -> new IllegalStateException("EnumTrait absent on provided string shape")); + if (enumTrait.hasNames() && hasInvalidEnumNames(enumTrait)) { + throw new IllegalStateException("Enum definition names must be uppercase alphanumeric and begin with a letter"); + } + if (!enumTrait.hasNames() && hasInvalidMembersForUnnamedEnum(enumTrait)) { + throw new IllegalStateException("Unnamed enum definitions cannot have documentation or tags, and can't be deprecated"); + } + return enumTrait; + } + + /** + * Note: + * - we don't currently do anything with tags + * - doc comments aren't generated for unnamed enum variants + * + * @return a class containing constants for the enum members + */ + public TokenTree generateEnumClass(final ShapeId stringShapeId) { + final StringShape stringShape = model.expectShape(stringShapeId, StringShape.class); + final EnumTrait enumTrait = getAndValidateEnumTrait(stringShape); + + final String enumClassName = nameResolver.classForEnum(stringShapeId); + final String enumValueTypeName = enumTrait.hasNames() ? enumClassName : "string"; + final TokenTree namedEnumValues = enumTrait.hasNames() + ? generateNamedEnumValues(enumTrait, enumClassName) + : TokenTree.empty(); + final TokenTree enumValuesArray = generateEnumValuesArray(enumTrait, enumValueTypeName); + + // For enums, the constructor does nothing except extend the parent ConstantClass constructor + final TokenTree constructor = TokenTree.of( + "public", + enumClassName, + "(string value)", + ": base(value)", + "{}" + ); + + final TokenTree classBody = TokenTree.of( + namedEnumValues, + enumValuesArray, + constructor + ).lineSeparated().braced(); + + final TokenTree constantClassImport = enumTrait.hasNames() ? Token.of("using Amazon.Runtime;") : TokenTree.empty(); + final TokenTree extendsConstantClass = enumTrait.hasNames() ? Token.of(": ConstantClass") : TokenTree.empty(); + + return TokenTree.of( + constantClassImport, + Token.of("public class"), + Token.of(enumClassName), + extendsConstantClass, + classBody + ).namespaced(Token.of(nameResolver.namespaceForService())); + } + + private boolean hasInvalidEnumNames(final EnumTrait enumTrait) { + return !enumTrait.getValues().stream() + .map(EnumDefinition::getName) + .map(Optional::get) + .allMatch(ModelUtils::isValidEnumDefinitionName); + } + + private boolean hasInvalidMembersForUnnamedEnum(final EnumTrait enumTrait) { + return enumTrait.getValues() + .stream() + .anyMatch(enumDefinition -> + enumDefinition.getDocumentation().isPresent() + || !enumDefinition.getTags().isEmpty() + || enumDefinition.isDeprecated() + ); + } + + private TokenTree generateNamedEnumValues(final EnumTrait enumTrait, final String enumClassName) { + return TokenTree.of(enumTrait.getValues().stream().map(enumDefinition -> { + assert enumDefinition.getName().isPresent(); + final String definitionName = enumDefinition.getName().get(); + + final TokenTree docComment = enumDefinition.getDocumentation() + .map(this::formatDocComment) + .orElse(TokenTree.empty()); + final TokenTree obsoleteAnnotation = enumDefinition.isDeprecated() + ? Token.of("[System.Obsolete]") + : TokenTree.empty(); + final TokenTree constDefinition = TokenTree.of( + "public static readonly", + enumClassName, + definitionName, + "= new", + enumClassName, + String.format("(\"%s\");", enumDefinition.getValue()) + ); + + return TokenTree.of(docComment, obsoleteAnnotation, constDefinition).lineSeparated(); + })); + } + + private TokenTree generateEnumValuesArray(final EnumTrait enumTrait, final String valueTypeName) { + final Stream valueStrings; + if (enumTrait.hasNames()) { + valueStrings = enumTrait.getValues() + .stream() + .map(EnumDefinition::getName) + .map(Optional::get) + .sorted() // Sort values for sane diffs + .map(Token::of); + } else { + valueStrings = enumTrait.getEnumDefinitionValues() + .stream() + .sorted() // Sort values for sane diffs + .map(value -> Token.of(String.format("\"%s\"", value))); + } + final TokenTree valuesArrayLiteral = TokenTree.of(valueStrings).separated(Token.of(",")).braced(); + return TokenTree.of( + Token.of("public static readonly "), + Token.of(valueTypeName), + Token.of("[] Values = "), + valuesArrayLiteral, + Token.of(';') + ); + } + + private TokenTree formatDocComment(final String docComment) { + final TokenTree start = Token.of("///

"); + final TokenTree body = TokenTree.of( + Arrays.stream(docComment.split("\n")) + .map(docLine -> TokenTree.of("///", docLine))).lineSeparated(); + final TokenTree end = Token.of("/// "); + return TokenTree.of(start, body, end).lineSeparated(); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/ShimCodegen.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/ShimCodegen.java new file mode 100644 index 0000000000..f4a17721b1 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/ShimCodegen.java @@ -0,0 +1,183 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import software.amazon.polymorph.utils.ModelUtils; +import software.amazon.polymorph.traits.ClientConfigTrait; +import software.amazon.polymorph.utils.Token; +import software.amazon.polymorph.utils.TokenTree; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.EntityShape; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ResourceShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.ShapeId; + +import java.nio.file.Path; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +public class ShimCodegen { + private final Model model; + private final ServiceShape serviceShape; + private final DotNetNameResolver nameResolver; + + private static final String IMPL_NAME = "_impl"; + + public ShimCodegen(final Model model, final ShapeId serviceShapeId) { + this.model = model; + this.serviceShape = model.expectShape(serviceShapeId, ServiceShape.class); + this.nameResolver = new DotNetNameResolver(model, serviceShape); + } + + /** + * Returns a map of service's and all resources' shim file paths to their generated ASTs. + */ + public Map generate() { + final Map codeByPath = new HashMap<>(); + final TokenTree prelude = TokenTree.of( + "using System;", + // Conditional imports. + // TODO: get smarter about imports. maybe just fully qualify all model-agnostic types? + "using System.IO;", + "using System.Collections.Generic;", + "using Aws.Crypto;", + // end conditional imports + "using", + nameResolver.namespaceForService(), + ";" + ).lineSeparated(); + + // Service shim + final Path serviceShimPath = Path.of(String.format("%s.cs", nameResolver.clientForService())); + final TokenTree serviceShimCode = generateServiceShim(); + codeByPath.put(serviceShimPath, serviceShimCode.prepend(prelude)); + + // Resource shims + model.getResourceShapes() + .stream() + .map(ResourceShape::getId) + .filter(resourceShapeId -> ModelUtils.isInServiceNamespace(resourceShapeId, serviceShape)) + .forEach(resourceShapeId -> { + final Path resourceShimPath = Path.of( + String.format("%s.cs", nameResolver.shimClassForResource(resourceShapeId))); + final TokenTree resourceShim = generateResourceShim(resourceShapeId); + codeByPath.put(resourceShimPath, resourceShim.prepend(prelude)); + }); + + return codeByPath; + } + + public TokenTree generateServiceShim() { + final TokenTree header = Token.of("public class %s : %s".formatted( + nameResolver.clientForService(), + nameResolver.baseClientForService())); + final TokenTree body = TokenTree.of( + generateServiceImplDeclaration(), + generateServiceConstructor(), + generateOperationShims(serviceShape.getId()) + ).lineSeparated(); + return header + .append(body.braced()) + .namespaced(Token.of(nameResolver.namespaceForService())); + } + + public TokenTree generateServiceConstructor() { + final Optional configShapeIdOptional = serviceShape.getTrait(ClientConfigTrait.class) + .map(ClientConfigTrait::getClientConfigId); + + final TokenTree configParam = configShapeIdOptional.map(shapeId -> TokenTree.of( + nameResolver.baseTypeForShape(shapeId), + "config" + )).orElse(TokenTree.empty()); + final TokenTree baseCtorCall = configShapeIdOptional.isPresent() + ? Token.of(": base(config)") : TokenTree.empty(); + final TokenTree configArg = configShapeIdOptional.map(shapeId -> TokenTree.of( + DotNetNameResolver.qualifiedTypeConverter(shapeId, TypeConversionDirection.TO_DAFNY), + "(config)" + )).orElse(TokenTree.empty()); + return Token.of("public %s(%s) %s { this.%s = new %s(%s); }".formatted( + nameResolver.clientForService(), + configParam, + baseCtorCall, + IMPL_NAME, + nameResolver.dafnyImplForServiceClient(), + configArg)); + } + + public TokenTree generateServiceImplDeclaration() { + return Token.of("private %s %s;".formatted(nameResolver.dafnyImplForServiceClient(), IMPL_NAME)); + } + + /** + * Generate a shim that wraps a Dafny-compiled implementation of the given resource interface. + * + * TODO: generate a shim that wraps a native C# implementation (i.e. customer-implemented) + */ + public TokenTree generateResourceShim(final ShapeId resourceShapeId) { + final TokenTree header = Token.of("internal class %s : %s".formatted( + nameResolver.shimClassForResource(resourceShapeId), + nameResolver.baseClassForResource(resourceShapeId))); + final TokenTree body = TokenTree.of( + generateResourceImplDeclaration(resourceShapeId), + generateResourceConstructor(resourceShapeId), + generateOperationShims(resourceShapeId) + ).lineSeparated(); + return header + .append(body.braced()) + .namespaced(Token.of(nameResolver.namespaceForService())); + } + + public TokenTree generateResourceConstructor(final ShapeId resourceShapeId) { + return Token.of("internal %s(%s impl) { this.%s = impl; }".formatted( + nameResolver.shimClassForResource(resourceShapeId), + nameResolver.dafnyTypeForShape(resourceShapeId), + IMPL_NAME)); + } + + public TokenTree generateResourceImplDeclaration(final ShapeId entityShapeId) { + return Token.of("internal %s %s { get; }".formatted( + nameResolver.dafnyTypeForShape(entityShapeId), IMPL_NAME)); + } + + public TokenTree generateOperationShims(final ShapeId entityShapeId) { + final EntityShape entityShape = model.expectShape(entityShapeId, EntityShape.class); + return TokenTree.of(entityShape.getAllOperations().stream().map(this::generateOperationShim)).lineSeparated(); + } + + public TokenTree generateOperationShim(final ShapeId operationShapeId) { + final OperationShape operationShape = model.expectShape(operationShapeId, OperationShape.class); + + final String outputType = operationShape.getOutput().map(nameResolver::baseTypeForShape).orElse("void"); + final String methodName = nameResolver.abstractMethodForOperation(operationShapeId); + final String param = operationShape.getInput() + .map(inputShapeId -> nameResolver.baseTypeForShape(inputShapeId) + " input") + .orElse(""); + final TokenTree signature = Token.of("protected override %s %s(%s)".formatted(outputType, methodName, param)); + + final TokenTree convertInput = Token.of(operationShape.getInput() + .map(inputShapeId -> "%s internalInput = %s(input);".formatted( + nameResolver.dafnyTypeForShape(inputShapeId), + DotNetNameResolver.qualifiedTypeConverter(inputShapeId, TypeConversionDirection.TO_DAFNY))) + .orElse("")); + final TokenTree assignInternalOutput = operationShape.getOutput() + .map(outputShapeId -> TokenTree.of(nameResolver.dafnyTypeForShape(outputShapeId), "internalOutput =")) + .orElse(TokenTree.empty()); + final TokenTree callImpl = Token.of("this.%s.%s(%s);".formatted( + IMPL_NAME, + nameResolver.methodForOperation(operationShapeId), + operationShape.getInput().isPresent() ? "internalInput" : "" + )); + final TokenTree convertAndReturnOutput = Token.of(operationShape.getOutput() + .map(outputShapeId -> "return %s(internalOutput);".formatted( + DotNetNameResolver.qualifiedTypeConverter(outputShapeId, TypeConversionDirection.FROM_DAFNY))) + .orElse("")); + + return TokenTree.of(convertInput, assignInternalOutput, callImpl, convertAndReturnOutput) + .lineSeparated() + .braced() + .prepend(signature); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/TypeConversionCodegen.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/TypeConversionCodegen.java new file mode 100644 index 0000000000..496d4e5671 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/TypeConversionCodegen.java @@ -0,0 +1,581 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.Sets; +import software.amazon.polymorph.utils.ModelUtils; +import software.amazon.polymorph.traits.ClientConfigTrait; +import software.amazon.polymorph.traits.DafnyUtf8BytesTrait; +import software.amazon.polymorph.traits.PositionalTrait; +import software.amazon.polymorph.traits.ReferenceTrait; +import software.amazon.polymorph.utils.Token; +import software.amazon.polymorph.utils.TokenTree; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.BlobShape; +import software.amazon.smithy.model.shapes.BooleanShape; +import software.amazon.smithy.model.shapes.IntegerShape; +import software.amazon.smithy.model.shapes.ListShape; +import software.amazon.smithy.model.shapes.LongShape; +import software.amazon.smithy.model.shapes.MapShape; +import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ResourceShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StringShape; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.shapes.TimestampShape; +import software.amazon.smithy.model.traits.EnumTrait; + +import java.nio.file.Path; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Queue; +import java.util.Set; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static software.amazon.polymorph.smithydotnet.DotNetNameResolver.TYPE_CONVERSION_CLASS_NAME; +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.FROM_DAFNY; +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.TO_DAFNY; + +/** + * Generates a {@code TypeConversion} class that includes all {@link TypeConverter}s needed for the operations in the + * provided {@link Model}. + */ +public class TypeConversionCodegen { + /** + * A pair of type converter methods that converts between the compiled Dafny representation and the idiomatic C# + * representation of a given {@link software.amazon.smithy.model.shapes.Shape} value. + */ + public static record TypeConverter(ShapeId shapeId, TokenTree fromDafny, TokenTree toDafny) {} + + public static final Path TYPE_CONVERSION_CLASS_PATH = Path.of(TYPE_CONVERSION_CLASS_NAME + ".cs"); + + protected final Model model; + protected final ServiceShape serviceShape; + protected final DotNetNameResolver nameResolver; + + public TypeConversionCodegen(final Model model, final ShapeId serviceShapeId) { + this(model, serviceShapeId, + new DotNetNameResolver(model, model.expectShape(serviceShapeId, ServiceShape.class))); + } + + public TypeConversionCodegen(final Model model, final ShapeId serviceShapeId, final DotNetNameResolver nameResolver) { + this.model = model; + this.serviceShape = model.expectShape(serviceShapeId, ServiceShape.class); + this.nameResolver = nameResolver; + } + + public Map generate() { + final TokenTree prelude = TokenTree.of( + // needed for LINQ operators like Select + "using System.Linq;", + // TODO: fully qualify types to avoid needing this + "using Aws.Crypto;" + ); + final Stream converters = findShapeIdsToConvert() + .stream() + .map(model::expectShape) + .map(this::generateConverter); + final TokenTree conversionClassBody = TokenTree.of(converters + .flatMap(typeConverter -> Stream.of(typeConverter.fromDafny, typeConverter.toDafny))) + .lineSeparated() + .braced(); + final TokenTree conversionClass = conversionClassBody + .prepend(TokenTree.of("internal static class", TYPE_CONVERSION_CLASS_NAME)) + .namespaced(Token.of(nameResolver.namespaceForService())); + return Map.of(TYPE_CONVERSION_CLASS_PATH, conversionClass.prepend(prelude)); + } + + /** + * Returns all shape IDs that require converters. + */ + @VisibleForTesting + public Set findShapeIdsToConvert() { + final Set shapesToConvert = new HashSet<>(); + + // Breadth-first search via getDependencyShapeIds + final Queue toTraverse = new LinkedList<>(findInitialShapeIdsToConvert()); + while (!toTraverse.isEmpty()) { + final ShapeId currentShapeId = toTraverse.remove(); + if (shapesToConvert.add(currentShapeId)) { + final Shape currentShape = model.expectShape(currentShapeId); + getDependencyShapeIds(currentShape).forEach(toTraverse::add); + } + } + return shapesToConvert; + } + + /** + * Returns a set of shape IDs for which to start generating type converter pairs, by recursively traversing + * services, resources, and operations defined in the model. + * + * Since type converters are only necessary when calling API operations, it suffices to find the shape IDs of all + * operation input and output structures. + */ + private Set findInitialShapeIdsToConvert() { + // Collect services + final Set serviceShapes = model.getServiceShapes().stream() + .filter(serviceShape -> isInServiceNamespace(serviceShape.getId())) + .collect(Collectors.toSet()); + + // Collect resources defined in model... + final Stream topLevelResourceShapes = model.getResourceShapes().stream() + .filter(resourceShape -> isInServiceNamespace(resourceShape.getId())); + // ... and resources of collected services. + final Stream serviceResourceShapes = serviceShapes.stream() + .flatMap(serviceShape -> serviceShape.getResources().stream()) + .map(resourceShapeId -> model.expectShape(resourceShapeId, ResourceShape.class)); + final Set resourceShapes = Stream.concat(topLevelResourceShapes, serviceResourceShapes) + .collect(Collectors.toSet()); + + // Collect operations defined in model... + final Stream topLevelOperationShapes = model.getOperationShapes().stream() + .filter(operationShape -> isInServiceNamespace(operationShape.getId())); + // ... and operations of collected services... + final Stream serviceOperationShapes = serviceShapes.stream() + .flatMap(serviceShape -> serviceShape.getAllOperations().stream()) + .map(operationShapeId -> model.expectShape(operationShapeId, OperationShape.class)); + // ... and operations of collected resources. + final Stream resourceOperationShapes = resourceShapes.stream() + .flatMap(resourceShape -> resourceShape.getAllOperations().stream()) + .map(operationShapeId -> model.expectShape(operationShapeId, OperationShape.class)); + final Set operationShapes = Stream + .of(topLevelOperationShapes, serviceOperationShapes, resourceOperationShapes) + .flatMap(Function.identity()) + .collect(Collectors.toSet()); + + // Collect inputs/output/error structures for collected operations + final Set operationStructures = operationShapes.stream() + .flatMap(operationShape -> { + final Stream inputOutput = Stream + .of(operationShape.getInput(), operationShape.getOutput()) + .flatMap(Optional::stream); + final Stream errors = operationShape.getErrors().stream(); + return Stream.concat(inputOutput, errors); + }) + .collect(Collectors.toSet()); + // Collect service client config structures + final Set clientConfigStructures = serviceShapes.stream() + .map(serviceShape -> serviceShape.getTrait(ClientConfigTrait.class)) + .flatMap(Optional::stream) + .map(ClientConfigTrait::getClientConfigId) + .collect(Collectors.toSet()); + return Sets.union(operationStructures, clientConfigStructures); + } + + private boolean isInServiceNamespace(final ShapeId shapeId) { + return shapeId.getNamespace().equals(serviceShape.getId().getNamespace()); + } + + /** + * Generates a {@link TypeConverter} for the given shape. + */ + @SuppressWarnings("OptionalGetWithoutIsPresent") + private TypeConverter generateConverter(final Shape shape) { + return switch (shape.getType()) { + case BLOB -> generateBlobConverter(shape.asBlobShape().get()); + case BOOLEAN -> generateBooleanConverter(shape.asBooleanShape().get()); + case STRING -> generateStringConverter(shape.asStringShape().get()); + case INTEGER -> generateIntegerConverter(shape.asIntegerShape().get()); + case LONG -> generateLongConverter(shape.asLongShape().get()); + case TIMESTAMP -> generateTimestampConverter(shape.asTimestampShape().get()); + case LIST -> generateListConverter(shape.asListShape().get()); + case MAP -> generateMapConverter(shape.asMapShape().get()); + case STRUCTURE -> generateStructureConverter(shape.asStructureShape().get()); + case MEMBER -> generateMemberConverter(shape.asMemberShape().get()); + default -> throw new IllegalStateException(); + }; + } + + /** + * Returns dependency shape IDs for the given shape. A shape {@code S} has a dependency shape {@code D} if a type + * converter for {@code S} requires the existence of a type converter for {@code D}. + */ + @SuppressWarnings("OptionalGetWithoutIsPresent") + private Stream getDependencyShapeIds(final Shape shape) { + return switch (shape.getType()) { + case LIST -> Stream.of(shape.asListShape().get().getMember().getId()); + case MAP -> { + final MapShape mapShape = shape.asMapShape().get(); + yield Stream.of(mapShape.getKey().getId(), mapShape.getValue().getId()); + } + case STRUCTURE -> ModelUtils.streamStructureMembers(shape.asStructureShape().get()).map(Shape::getId); + case MEMBER -> Stream.of(shape.asMemberShape().get().getTarget()); + default -> Stream.empty(); + }; + } + + public TypeConverter generateBlobConverter(final BlobShape blobShape) { + final TokenTree fromDafnyBody = Token.of("return new System.IO.MemoryStream(value.Elements);"); + final TokenTree toDafnyBody = Token.of("return Dafny.Sequence.FromArray(value.ToArray());"); + return buildConverterFromMethodBodies(blobShape, fromDafnyBody, toDafnyBody); + } + + public TypeConverter generateBooleanConverter(final BooleanShape booleanShape) { + final TokenTree fromDafnyBody = Token.of("return value;"); + final TokenTree toDafnyBody = Token.of("return value;"); + return buildConverterFromMethodBodies(booleanShape, fromDafnyBody, toDafnyBody); + } + + public TypeConverter generateStringConverter(final StringShape stringShape) { + if (stringShape.hasTrait(EnumTrait.class)) { + return generateEnumConverter(stringShape, stringShape.expectTrait(EnumTrait.class)); + } + + if (stringShape.hasTrait(DafnyUtf8BytesTrait.class)) { + return generateUtf8BytesConverter(stringShape); + } + + final TokenTree fromDafnyBody = Token.of("return new string(value.Elements);"); + final TokenTree toDafnyBody = Token.of("return Dafny.Sequence.FromString(value);"); + return buildConverterFromMethodBodies(stringShape, fromDafnyBody, toDafnyBody); + } + + public TypeConverter generateIntegerConverter(final IntegerShape integerShape) { + final TokenTree fromDafnyBody = Token.of("return value;"); + final TokenTree toDafnyBody = Token.of("return value;"); + return buildConverterFromMethodBodies(integerShape, fromDafnyBody, toDafnyBody); + } + + public TypeConverter generateLongConverter(final LongShape longShape) { + final TokenTree fromDafnyBody = Token.of("return value;"); + final TokenTree toDafnyBody = Token.of("return value;"); + return buildConverterFromMethodBodies(longShape, fromDafnyBody, toDafnyBody); + } + + public TypeConverter generateTimestampConverter(final TimestampShape timestampShape) { + final TokenTree fromDafnyBody = Token.of(""" + System.Globalization.CultureInfo culture = new System.Globalization.CultureInfo(""); + string timestampString = new string(value.Elements); + return System.DateTime.ParseExact(timestampString, "s", culture); + """); + final TokenTree toDafnyBody = Token.of(""" + System.Globalization.CultureInfo culture = new System.Globalization.CultureInfo(""); + string timestampString = value.ToString("s", culture); + return Dafny.Sequence.FromString(timestampString); + """); + return buildConverterFromMethodBodies(timestampShape, fromDafnyBody, toDafnyBody); + } + + protected boolean enumListMembersAreStringsInCSharp() { + return false; + } + + public TypeConverter generateListConverter(final ListShape listShape) { + final String listCSharpType = nameResolver.baseTypeForList(listShape); + + final MemberShape memberShape = listShape.getMember(); + final String memberDafnyType = nameResolver.dafnyTypeForShape(memberShape.getId()); + final String memberCSharpType = nameResolver.baseTypeForMember(memberShape);; + + final String memberToDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShape.getId(), TO_DAFNY); + final String memberFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShape.getId(), FROM_DAFNY); + + final boolean convertMemberEnumToString = enumListMembersAreStringsInCSharp() + && model.expectShape(memberShape.getTarget()).hasTrait(EnumTrait.class); + final String fromDafnyEnumConversion = convertMemberEnumToString + ? ".Select<%s, string>(x => x)".formatted(memberCSharpType) + : ""; + final String toDafnyEnumConversion = convertMemberEnumToString + ? ".Select(x => x)".formatted(memberCSharpType) + : ""; + + final TokenTree fromDafnyBody = Token.of( + "return new %s(value.Elements.Select(%s)%s);".formatted( + listCSharpType, + memberFromDafnyConverterName, + fromDafnyEnumConversion)); + + final TokenTree toDafnyBody = Token.of( + "return Dafny.Sequence<%s>.FromArray(value%s.Select(%s).ToArray());".formatted( + memberDafnyType, + toDafnyEnumConversion, + memberToDafnyConverterName)); + + return buildConverterFromMethodBodies(listShape, fromDafnyBody, toDafnyBody); + } + + public TypeConverter generateMapConverter(final MapShape mapShape) { + final MemberShape keyShape = mapShape.getKey(); + final MemberShape valueShape = mapShape.getValue(); + final String keyDafnyType = nameResolver.dafnyTypeForShape(keyShape.getId()); + final String valueDafnyType = nameResolver.dafnyTypeForShape(valueShape.getId()); + + final String keyToDafnyConverterName = DotNetNameResolver.typeConverterForShape(keyShape.getId(), TO_DAFNY); + final String keyFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(keyShape.getId(), FROM_DAFNY); + final String valueToDafnyConverterName = DotNetNameResolver.typeConverterForShape(valueShape.getId(), TO_DAFNY); + final String valueFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(valueShape.getId(), FROM_DAFNY); + + final TokenTree fromDafnyBody = Token.of( + "return value.ItemEnumerable.ToDictionary(pair => %s(pair.Car), pair => %s(pair.Cdr));" + .formatted(keyFromDafnyConverterName, valueFromDafnyConverterName)); + + final String dafnyMapTypeArgs = "<%s, %s>".formatted(keyDafnyType, valueDafnyType); + final TokenTree toDafnyBody = Token.of(""" + return Dafny.Map%s.FromCollection(value.Select(pair => + new Dafny.Pair%s(%s(pair.Key), %s(pair.Value)) + ));""" + .formatted(dafnyMapTypeArgs, dafnyMapTypeArgs, keyToDafnyConverterName, valueToDafnyConverterName)); + return buildConverterFromMethodBodies(mapShape, fromDafnyBody, toDafnyBody); + } + + public TypeConverter generateStructureConverter(final StructureShape structureShape) { + final Optional referenceTraitOptional = structureShape.getTrait(ReferenceTrait.class); + if (referenceTraitOptional.isPresent()) { + return generateReferenceStructureConverter(structureShape, referenceTraitOptional.get()); + } + + final Optional positionalTraitOptional = structureShape.getTrait(PositionalTrait.class); + if (positionalTraitOptional.isPresent()) { + return generatePositionalStructureConverter(structureShape); + } + + return generateRegularStructureConverter(structureShape); + } + + /** + * This should not be called directly, instead call + * {@link TypeConversionCodegen#generateStructureConverter(StructureShape)}. + */ + private TypeConverter generateRegularStructureConverter(final StructureShape structureShape) { + final TokenTree assignments = TokenTree.of(ModelUtils.streamStructureMembers(structureShape) + .map(memberShape -> { + final String dafnyMemberName = memberShape.getMemberName(); + final String propertyName = nameResolver.classPropertyForStructureMember(memberShape); + final String propertyType = nameResolver.classPropertyTypeForStructureMember(memberShape); + final String memberFromDafnyConverterName = DotNetNameResolver.typeConverterForShape( + memberShape.getId(), FROM_DAFNY); + + final TokenTree checkIfPresent; + if (nameResolver.memberShapeIsOptional(memberShape)) { + final String isPresent = ModelUtils.memberShapeTargetsEntityReference(model, memberShape) + ? "!= null" + : ".is_Some"; + checkIfPresent = Token.of("if (value.%s %s)".formatted(dafnyMemberName, isPresent)); + } else { + checkIfPresent = TokenTree.empty(); + } + final TokenTree assign = Token.of("converted.%s = (%s) %s(value.%s);".formatted( + propertyName, propertyType, memberFromDafnyConverterName, dafnyMemberName)); + return TokenTree.of(checkIfPresent, assign); + })).lineSeparated(); + final String structureType = nameResolver.baseTypeForShape(structureShape.getId()); + final TokenTree fromDafnyBody = TokenTree.of( + Token.of("%1$s converted = new %1$s();".formatted(structureType)), + assignments, + Token.of("return converted;") + ); + + final TokenTree constructorArgs = TokenTree.of(ModelUtils.streamStructureMembers(structureShape) + .map(memberShape -> "%s(value.%s)".formatted( + DotNetNameResolver.typeConverterForShape(memberShape.getId(), TO_DAFNY), + nameResolver.classPropertyForStructureMember(memberShape))) + .map(Token::of) + ).separated(Token.of(',')); + final TokenTree toDafnyBody = TokenTree.of( + Token.of("return new"), + Token.of(nameResolver.dafnyTypeForShape(structureShape.getId())), + constructorArgs.parenthesized(), + Token.of(';') + ); + + return buildConverterFromMethodBodies(structureShape, fromDafnyBody, toDafnyBody); + } + + public TypeConverter generateMemberConverter(final MemberShape memberShape) { + final Shape targetShape = model.expectShape(memberShape.getTarget()); + + final String targetFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(targetShape.getId(), FROM_DAFNY); + final String targetToDafnyConverterName = DotNetNameResolver.typeConverterForShape(targetShape.getId(), TO_DAFNY); + + // Entity references are represented as Dafny traits, and Dafny traits can't be type parameters. So in the + // Dafny implementation of the model, an optional entity reference member is represented as a nullable type T? + // instead of an Optional. This works around the limitation. + // TODO: remove workaround when https://github.com/dafny-lang/dafny/issues/1499 is resolved + final boolean targetIsEntityReference = targetShape.hasTrait(ReferenceTrait.class); + + if (!nameResolver.memberShapeIsOptional(memberShape) || targetIsEntityReference) { + final TokenTree fromDafnyBody = Token.of("return %s(value);".formatted(targetFromDafnyConverterName)); + final TokenTree toDafnyBody = Token.of("return %s(value);".formatted(targetToDafnyConverterName)); + return buildConverterFromMethodBodies(memberShape, fromDafnyBody, toDafnyBody); + } + + final String cSharpType = nameResolver.baseTypeForShape(targetShape.getId()); + final String cSharpOptionType = nameResolver.baseTypeForShape(memberShape.getId()); + final String dafnyOptionType = nameResolver.dafnyTypeForShape(memberShape.getId()); + final TokenTree fromDafnyBody = Token.of("return value.is_None ? (%s) null : %s(value.Extract());" + .formatted(cSharpOptionType, targetFromDafnyConverterName)); + final TokenTree toDafnyBody = Token.of( + "return value == null ? %s.create_None() : %s.create_Some(%s((%s) value));" + .formatted(dafnyOptionType, dafnyOptionType, targetToDafnyConverterName, cSharpType)); + return buildConverterFromMethodBodies(memberShape, fromDafnyBody, toDafnyBody); + } + + /** + * This should not be called directly, instead call + * {@link TypeConversionCodegen#generateStructureConverter(StructureShape)}. + */ + protected TypeConverter generateReferenceStructureConverter( + final StructureShape structureShape, final ReferenceTrait referenceTrait) { + final ShapeId referentId = referenceTrait.getReferentId(); + return switch (referenceTrait.getReferentType()) { + case SERVICE -> generateServiceReferenceStructureConverter( + structureShape, model.expectShape(referentId, ServiceShape.class)); + case RESOURCE -> generateResourceReferenceStructureConverter( + structureShape, model.expectShape(referentId, ResourceShape.class)); + }; + } + + /** + * This should not be called directly, instead call + * {@link TypeConversionCodegen#generateStructureConverter(StructureShape)}. + * + * Note that this currently only allows for C# implementations of AWS SDK service interfaces. + */ + protected TypeConverter generateServiceReferenceStructureConverter( + final StructureShape structureShape, final ServiceShape serviceShape) { + // TODO is this actually a good filter for AWS SDK services? + if (!serviceShape.getId().getNamespace().startsWith("com.amazonaws.")) { + throw new UnsupportedOperationException("Only AWS SDK service client converters are supported"); + } + + final AwsSdkTypeConversionCodegen awsSdkTypeConversionCodegen = + new AwsSdkTypeConversionCodegen(model, serviceShape.getId()); + return awsSdkTypeConversionCodegen.generateAwsSdkServiceReferenceStructureConverter(structureShape); + } + + /** + * This should not be called directly, instead call + * {@link TypeConversionCodegen#generateStructureConverter(StructureShape)}. + * + * Note that this currently only allows for Dafny-compiled implementations of the resource interface. + * + * TODO: allow for native C# implementations (i.e. customer-implemented) of resources + */ + protected TypeConverter generateResourceReferenceStructureConverter( + final StructureShape structureShape, final ResourceShape resourceShape) { + final ShapeId resourceShapeId = resourceShape.getId(); + + final TokenTree fromDafnyBody = Token.of("return new %s(value);" + .formatted(nameResolver.shimClassForResource(resourceShapeId))); + final TokenTree toDafnyBody = Token.of(""" + if (value is %s valueWithImpl) { + return valueWithImpl._impl; + } + throw new System.ArgumentException(\"Custom implementations of %s are not supported yet\"); + """.formatted( + nameResolver.shimClassForResource(resourceShapeId), + nameResolver.baseTypeForShape(resourceShapeId))); + + return buildConverterFromMethodBodies(structureShape, fromDafnyBody, toDafnyBody); + } + + /** + * This should not be called directly, instead call + * {@link TypeConversionCodegen#generateStructureConverter(StructureShape)}. + */ + private TypeConverter generatePositionalStructureConverter(final StructureShape structureShape) { + final ShapeId memberShapeId = ModelUtils.getPositionalStructureMember(structureShape).orElseThrow(); + + final String memberFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShapeId, FROM_DAFNY); + final String memberToDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShapeId, TO_DAFNY); + final TokenTree fromDafnyBody = Token.of("return %s(value);".formatted(memberFromDafnyConverterName)); + final TokenTree toDafnyBody = Token.of("return %s(value);".formatted(memberToDafnyConverterName)); + + return buildConverterFromMethodBodies(structureShape, fromDafnyBody, toDafnyBody); + } + + /** + * A pair of names for a {@link software.amazon.smithy.model.traits.EnumDefinition}, consisting of the + * Smithy-defined name (the {@link EnumDefNames#defName}) and the Dafny-compiler-generated name (the + * {@link EnumDefNames#dafnyName}). + */ + private static record EnumDefNames(String defName, String dafnyName) {} + + /** + * This should not be called directly, instead call + * {@link TypeConversionCodegen#generateStringConverter(StringShape)}. + */ + private TypeConverter generateEnumConverter(final StringShape stringShape, final EnumTrait enumTrait) { + assert enumTrait.hasNames(); + //noinspection OptionalGetWithoutIsPresent + final List defNames = enumTrait.getValues().stream() + .map(enumDefinition -> enumDefinition.getName().get()) + .map(name -> new EnumDefNames(name, DotNetNameResolver.dafnyCompiledNameForEnumDefinitionName(name))) + .toList(); + final String enumClass = nameResolver.baseTypeForShape(stringShape.getId()); + final String dafnyEnumBaseClass = nameResolver.dafnyTypeForShape(stringShape.getId()); + final Token throwInvalidEnumValue = Token.of("\nthrow new System.ArgumentException(\"Invalid %s value\");" + .formatted(enumClass)); + + final TokenTree fromDafnyBody = TokenTree.of(defNames.stream() + .map(names -> "if (value.is_%s) return %s.%s;".formatted(names.dafnyName, enumClass, names.defName)) + .map(Token::of)) + .lineSeparated() + .append(throwInvalidEnumValue); + + final TokenTree toDafnyBody = TokenTree.of(defNames.stream() + .map(names -> { + final String condition = "%s.%s.Equals(value)".formatted(enumClass, names.defName); + // Dafny doesn't generate a "create_FOOBAR" ctor if there's only one ctor + final String construct = defNames.size() == 1 + ? "new %s()".formatted(dafnyEnumBaseClass) + : "%s.create_%s()".formatted(dafnyEnumBaseClass, names.dafnyName); + return "if (%s) return %s;".formatted(condition, construct); + }) + .map(Token::of)) + .lineSeparated() + .append(throwInvalidEnumValue); + + return buildConverterFromMethodBodies(stringShape, fromDafnyBody, toDafnyBody); + } + + /** + * @see DafnyUtf8BytesTrait + */ + private TypeConverter generateUtf8BytesConverter(final StringShape stringShape) { + final TokenTree fromDafnyBody = Token.of(""" + System.Text.UTF8Encoding utf8 = new System.Text.UTF8Encoding(false, true); + return utf8.GetString(value.Elements);"""); + final TokenTree toDafnyBody = Token.of(""" + System.Text.UTF8Encoding utf8 = new System.Text.UTF8Encoding(false, true); + return Dafny.Sequence.FromArray(utf8.GetBytes(value));"""); + return buildConverterFromMethodBodies(stringShape, fromDafnyBody, toDafnyBody); + } + + /** + * Build a {@link TypeConverter} by surrounding the given type converter method bodies with appropriate method + * signatures. Each method body should assume the sole argument (the value to convert) is named {@code value}. + */ + protected TypeConverter buildConverterFromMethodBodies( + final Shape shape, final TokenTree fromDafnyBody, final TokenTree toDafnyBody) { + final String dafnyType = nameResolver.dafnyTypeForShape(shape.getId()); + final String cSharpType = nameResolver.baseTypeForShape(shape.getId()); + + final String fromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shape.getId(), FROM_DAFNY); + final TokenTree fromDafnyConverterSignature = TokenTree.of( + "public static", cSharpType, fromDafnyConverterName, "(%s value)".formatted(dafnyType)); + final TokenTree fromDafnyConverterMethod = TokenTree.of(fromDafnyConverterSignature, fromDafnyBody.braced()); + + final String toDafnyConverterName = DotNetNameResolver.typeConverterForShape(shape.getId(), TO_DAFNY); + final TokenTree toDafnyConverterSignature = TokenTree.of( + "public static", dafnyType, toDafnyConverterName, "(%s value)".formatted(cSharpType)); + final TokenTree toDafnyConverterMethod = TokenTree.of(toDafnyConverterSignature, toDafnyBody.braced()); + + return new TypeConverter(shape.getId(), fromDafnyConverterMethod, toDafnyConverterMethod); + } + + @VisibleForTesting + public Model getModel() { + return model; + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/TypeConversionDirection.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/TypeConversionDirection.java new file mode 100644 index 0000000000..0b9fe6def9 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/smithydotnet/TypeConversionDirection.java @@ -0,0 +1,9 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +public enum TypeConversionDirection { + TO_DAFNY, + FROM_DAFNY +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/ClientConfigTrait.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/ClientConfigTrait.java new file mode 100644 index 0000000000..81073791ef --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/ClientConfigTrait.java @@ -0,0 +1,104 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.traits; + +import software.amazon.smithy.model.node.Node; +import software.amazon.smithy.model.node.ObjectNode; +import software.amazon.smithy.model.node.StringNode; +import software.amazon.smithy.model.selector.Selector; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.AbstractTrait; +import software.amazon.smithy.model.traits.AbstractTraitBuilder; +import software.amazon.smithy.model.traits.Trait; +import software.amazon.smithy.model.traits.TraitDefinition; +import software.amazon.smithy.utils.SmithyBuilder; +import software.amazon.smithy.utils.ToSmithyBuilder; + +import java.util.Optional; + +/** + * A trait indicating the structure that should be used as the client configuration object when generating the client + * code for a service structure. + */ +public class ClientConfigTrait extends AbstractTrait implements ToSmithyBuilder { + public static final ShapeId ID = ShapeId.from("aws.polymorph#clientConfig"); + + private final ShapeId clientConfigId; + + private static final String CONFIG = "config"; + + private ClientConfigTrait(Builder builder) { + super(ID, builder.getSourceLocation()); + this.clientConfigId = builder.clientConfigId; + } + + public static final class Provider extends AbstractTrait.Provider { + public Provider() { + super(ID); + } + + @Override + public Trait createTrait(ShapeId target, Node value) { + ObjectNode objectNode = value.expectObjectNode(); + Optional configIdOptional = objectNode.getStringMember(CONFIG).map(StringNode::expectShapeId); + ShapeId configId = configIdOptional.orElseThrow(() -> new IllegalStateException("Must specify a config")); + + return builder() + .clientConfigId(configId) + .build(); + } + } + + public static Builder builder() { + return new Builder(); + } + + public ShapeId getClientConfigId() { + return this.clientConfigId; + } + + @Override + protected Node createNode() { + return Node.objectNodeBuilder() + .sourceLocation(getSourceLocation()) + .withMember(CONFIG, this.clientConfigId.toString()) + .build(); + } + + @Override + public SmithyBuilder toBuilder() { + return builder() + .sourceLocation(getSourceLocation()); + } + + /** Builder for {@link ClientConfigTrait}. */ + public static final class Builder extends AbstractTraitBuilder { + private ShapeId clientConfigId; + + private Builder() {} + + @Override + public ClientConfigTrait build() { + return new ClientConfigTrait(this); + } + + public Builder clientConfigId(ShapeId clientConfigId) { + this.clientConfigId = clientConfigId; + return this; + } + } + + public static Shape getDefinition() { + final Trait clientConfigTraitDefinition = TraitDefinition.builder() + .selector(Selector.parse("service")) + .build(); + return StructureShape.builder() + .id(ClientConfigTrait.ID) + .addTrait(clientConfigTraitDefinition) + .addMember(CONFIG, ShapeId.from("smithy.api#String")) + .build(); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/DafnyUtf8BytesTrait.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/DafnyUtf8BytesTrait.java new file mode 100644 index 0000000000..dabd3e9957 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/DafnyUtf8BytesTrait.java @@ -0,0 +1,59 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.traits; + +import software.amazon.smithy.model.node.Node; +import software.amazon.smithy.model.node.ObjectNode; +import software.amazon.smithy.model.selector.Selector; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.AnnotationTrait; +import software.amazon.smithy.model.traits.Trait; +import software.amazon.smithy.model.traits.TraitDefinition; + +/** + * Indicates that a string is represented as a sequence of UTF-8 encoded bytes in Dafny, rather than the default + * sequence of UTF-16 chars. + *

+ * This trait is a workaround. Smithy "string" types represent UTF-8, but Dafny and C# natively use UTF-16 as the + * primary char and string primitive types. So normally, generated/compiled Dafny and C# code would just use UTF-16 to + * represent string types. But the Dafny implementation (and generated API) use explicit UTF-8 byte arrays where doing + * so makes verification easier. So we need this mechanism in the model to tell codegen which Dafny representation will + * be used: sequences of UTF-16 chars or UTF-8 bytes. + *

+ * The current plan is to change the definition of string in Dafny 4.0 to support Unicode in general better. When that + * lands we should be able to make the necessary changes to clean this up in the codegen/model without affecting any + * customers (who WILL be using their idiomatic representation of strings). + *

+ * See: dafny-lang/dafny#413: Revisit definition of Dafny strings + */ +// TODO: remove this trait +public final class DafnyUtf8BytesTrait extends AnnotationTrait { + public static final ShapeId ID = ShapeId.from("aws.polymorph#dafnyUtf8Bytes"); + + public DafnyUtf8BytesTrait(ObjectNode node) { + super(ID, node); + } + + public DafnyUtf8BytesTrait() { + this(Node.objectNode()); + } + + public static final class Provider extends AnnotationTrait.Provider { + public Provider() { + super(ID, DafnyUtf8BytesTrait::new); + } + } + + public static Shape getDefinition() { + final Trait traitDefinition = TraitDefinition.builder() + .selector(Selector.parse("string")) + .build(); + return StructureShape.builder() + .id(DafnyUtf8BytesTrait.ID) + .addTrait(traitDefinition) + .build(); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/PositionalTrait.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/PositionalTrait.java new file mode 100644 index 0000000000..eead9d7bb9 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/PositionalTrait.java @@ -0,0 +1,76 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.traits; + +import software.amazon.smithy.model.node.Node; +import software.amazon.smithy.model.selector.Selector; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.AbstractTrait; +import software.amazon.smithy.model.traits.AbstractTraitBuilder; +import software.amazon.smithy.model.traits.Trait; +import software.amazon.smithy.model.traits.TraitDefinition; +import software.amazon.smithy.utils.SmithyBuilder; +import software.amazon.smithy.utils.ToSmithyBuilder; + +/** + * A trait representing that a structure should be "unwrapped" to its member whenever it is referenced. + */ +public class PositionalTrait extends AbstractTrait implements ToSmithyBuilder { + public static final ShapeId ID = ShapeId.from("aws.polymorph#positional"); + + private PositionalTrait(Builder builder) { + super(ID, builder.getSourceLocation()); + } + + public static final class Provider extends AbstractTrait.Provider { + public Provider() { + super(ID); + } + + @Override + public Trait createTrait(ShapeId target, Node value) { + return builder().build(); + } + } + + public static Builder builder() { + return new Builder(); + } + + @Override + protected Node createNode() { + return Node.objectNodeBuilder() + .sourceLocation(getSourceLocation()) + .build(); + } + + @Override + public SmithyBuilder toBuilder() { + return builder() + .sourceLocation(getSourceLocation()); + } + + /** Builder for {@link PositionalTrait}. */ + public static final class Builder extends AbstractTraitBuilder { + + private Builder() {} + + @Override + public PositionalTrait build() { + return new PositionalTrait(this); + } + } + + public static Shape getDefinition() { + final Trait positionalTraitDefinition = TraitDefinition.builder() + .selector(Selector.parse("structure")) + .build(); + return StructureShape.builder() + .id(PositionalTrait.ID) + .addTrait(positionalTraitDefinition) + .build(); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/ReferenceTrait.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/ReferenceTrait.java new file mode 100644 index 0000000000..dd038310f2 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/traits/ReferenceTrait.java @@ -0,0 +1,146 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.traits; + +import software.amazon.smithy.model.node.Node; +import software.amazon.smithy.model.node.ObjectNode; +import software.amazon.smithy.model.node.StringNode; +import software.amazon.smithy.model.selector.Selector; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.AbstractTrait; +import software.amazon.smithy.model.traits.AbstractTraitBuilder; +import software.amazon.smithy.model.traits.Trait; +import software.amazon.smithy.model.traits.TraitDefinition; +import software.amazon.smithy.utils.SmithyBuilder; +import software.amazon.smithy.utils.ToSmithyBuilder; + +import java.util.Optional; + +/** + * A trait representing a reference to either a service or resource, which we call the referent. A process holding such + * a reference can invoke operations on the referent. + */ +public class ReferenceTrait extends AbstractTrait implements ToSmithyBuilder { + public static final ShapeId ID = ShapeId.from("aws.polymorph#reference"); + + private static final String SERVICE = "service"; + private static final String RESOURCE = "resource"; + + private final ReferentType referentType; + private final ShapeId referentId; + + private ReferenceTrait(Builder builder) { + super(ID, builder.getSourceLocation()); + this.referentType = builder.referentType; + this.referentId = builder.referentId; + } + + public static final class Provider extends AbstractTrait.Provider { + public Provider() { + super(ID); + } + + @Override + public Trait createTrait(ShapeId target, Node value) { + ObjectNode objectNode = value.expectObjectNode(); + Optional serviceId = objectNode.getStringMember(SERVICE).map(StringNode::expectShapeId); + Optional resourceId = objectNode.getStringMember(RESOURCE).map(StringNode::expectShapeId); + if (serviceId.isPresent() == resourceId.isPresent()) { + throw new IllegalStateException("Must specify either service or resource, but not both"); + } + ReferentType referentType = serviceId.isPresent() ? ReferentType.SERVICE : ReferentType.RESOURCE; + ShapeId referentId = serviceId.orElseGet(resourceId::get); + + return builder() + .referentType(referentType) + .referentId(referentId) + .build(); + } + } + + public static Builder builder() { + return new Builder(); + } + + public ReferentType getReferentType() { + return referentType; + } + + public ShapeId getReferentId() { + return referentId; + } + + public enum ReferentType { + SERVICE, RESOURCE; + + @Override + public String toString() { + return switch (this) { + case SERVICE -> ReferenceTrait.SERVICE; + case RESOURCE -> ReferenceTrait.RESOURCE; + }; + } + + public static ReferentType fromString(String referentTypeStr) { + return switch (referentTypeStr) { + case ReferenceTrait.SERVICE -> SERVICE; + case ReferenceTrait.RESOURCE -> RESOURCE; + default -> throw new UnsupportedOperationException(); + }; + } + } + + @Override + protected Node createNode() { + return Node.objectNodeBuilder() + .sourceLocation(getSourceLocation()) + .withMember(this.referentType.toString(), this.referentId.toString()) + .build(); + } + + @Override + public SmithyBuilder toBuilder() { + return builder() + .sourceLocation(getSourceLocation()) + .referentType(this.getReferentType()) + .referentId(this.getReferentId()); + } + + /** Builder for {@link ReferenceTrait}. */ + public static final class Builder extends AbstractTraitBuilder { + private ReferentType referentType; + private ShapeId referentId; + + private Builder() {} + + @Override + public ReferenceTrait build() { + return new ReferenceTrait(this); + } + + public Builder referentType(ReferentType referentType) { + this.referentType = referentType; + return this; + } + + public Builder referentId(ShapeId referentId) { + this.referentId = referentId; + return this; + } + } + + public static Shape getDefinition() { + final Trait referenceTraitDefinition = TraitDefinition.builder() + .selector(Selector.parse("structure")) + .build(); + return StructureShape.builder() + .id(ReferenceTrait.ID) + .addTrait(referenceTraitDefinition) + .addMember("service", ShapeId.from("smithy.api#String")) + .addMember("resource", ShapeId.from("smithy.api#String")) + .build(); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/utils/ModelUtils.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/utils/ModelUtils.java new file mode 100644 index 0000000000..be8af8d6a9 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/utils/ModelUtils.java @@ -0,0 +1,121 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.utils; + +import com.google.common.base.Joiner; +import software.amazon.polymorph.traits.ClientConfigTrait; +import software.amazon.polymorph.traits.PositionalTrait; +import software.amazon.polymorph.traits.ReferenceTrait; +import software.amazon.polymorph.traits.DafnyUtf8BytesTrait; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.loader.ModelAssembler; +import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.utils.StringUtils; + +import java.util.Arrays; +import java.util.Optional; +import java.util.TreeSet; +import java.util.regex.Pattern; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public class ModelUtils { + // Require title-case alphanumeric names, so we don't need to check for keyword conflicts. + // + // The spec recommends a similar stricter definition for consistency (uppercase instead of title-case): + // https://awslabs.github.io/smithy/1.0/spec/core/constraint-traits.html?highlight=enum#enum-trait + private static final Pattern ENUM_NAME_PATTERN = Pattern.compile("^[A-Z]+[A-Za-z_0-9]*$"); + + /** + * Adds our custom traits (and their definitions) to a {@link ModelAssembler}. + * + * Note that this only needs to be called if the model file(s) being processed do not define these traits + * (for example, in unit tests). If the model file does define the traits, adding them again does nothing. + */ + public static void addCustomTraitsToModelAssembler(final ModelAssembler assembler) { + assembler.addShape(ReferenceTrait.getDefinition()); + assembler.addShape(PositionalTrait.getDefinition()); + assembler.addShape(ClientConfigTrait.getDefinition()); + assembler.addShape(DafnyUtf8BytesTrait.getDefinition()); + } + + /** + * @return a stream of members of the given structure shape + */ + public static Stream streamStructureMembers(final StructureShape structureShape) { + return structureShape.getAllMembers().values().stream(); + } + + /** + * @return a stream of error structures in the given service shape + */ + public static Stream streamServiceErrors(final Model model, final ServiceShape serviceShape) { + return serviceShape.getAllOperations() + .stream() + .map(shapeId -> model.expectShape(shapeId, OperationShape.class)) + .flatMap(operationShape -> operationShape.getErrors().stream()) + .map(errorShapeId -> model.expectShape(errorShapeId, StructureShape.class)); + } + + /** + * @return true if the given shape ID is in the given service's namespace + */ + public static boolean isInServiceNamespace(final ShapeId shapeId, final ServiceShape serviceShape) { + return shapeId.getNamespace().equals(serviceShape.getId().getNamespace()); + } + + /** + * Returns the sole member of the given positional structure shape, or {@link Optional#empty()} if the given shape + * isn't a positional structure. + */ + public static Optional getPositionalStructureMember(final Shape shape) { + if (!shape.hasTrait(PositionalTrait.class)) { + return Optional.empty(); + } + + if (shape.members().size() != 1) { + // For now, we only intend this trait to be used for operation returns, so we therefore only allow one + // member. Eventually if we also want to use this to unwrap operation inputs (or any more general + // unwrapping) we'll need to relax this constraint. + throw new IllegalStateException("Structures marked with '@positional' must have exactly one member"); + } + + //noinspection OptionalGetWithoutIsPresent + final MemberShape memberShape = shape.members() + .stream() + .findFirst() + .get(); + return Optional.of(memberShape.getId()); + } + + public static boolean memberShapeIsOptional(final Model model, final MemberShape memberShape) { + final Shape containerShape = model.expectShape(memberShape.getContainer()); + return containerShape.isStructureShape() + && !containerShape.hasTrait(PositionalTrait.class) + && !memberShape.isRequired(); + } + + public static boolean memberShapeTargetsEntityReference(final Model model, final MemberShape memberShape) { + return Optional.of(memberShape.getTarget()) + .flatMap(model::getShape) + .flatMap(targetShape -> targetShape.getTrait(ReferenceTrait.class)) + .isPresent(); + } + + /** + * Returns true if the given shape ID is in the {@code smithy.api} namespace, or false otherwise. + */ + public static boolean isSmithyApiShape(final ShapeId shapeId) { + return shapeId.getNamespace().equals("smithy.api"); + } + + public static boolean isValidEnumDefinitionName(final String name) { + return ENUM_NAME_PATTERN.matcher(name).matches(); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/utils/Token.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/utils/Token.java new file mode 100644 index 0000000000..53779e8385 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/utils/Token.java @@ -0,0 +1,27 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.utils; + +public class Token extends TokenTree { + public static final Token NEWLINE = Token.of("\n"); + + private final CharSequence chars; + + public Token(final CharSequence chars) { + this.chars = chars; + } + + public static Token of(char singleChar) { + return new Token(String.valueOf(singleChar)); + } + + public static Token of(final CharSequence chars) { + return new Token(chars); + } + + @Override + public String toString() { + return chars == null ? "" : chars.toString(); + } +} diff --git a/smithy-dotnet/src/main/java/software/amazon/polymorph/utils/TokenTree.java b/smithy-dotnet/src/main/java/software/amazon/polymorph/utils/TokenTree.java new file mode 100644 index 0000000000..4cd1ecdab5 --- /dev/null +++ b/smithy-dotnet/src/main/java/software/amazon/polymorph/utils/TokenTree.java @@ -0,0 +1,103 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.utils; + +import com.google.common.collect.ImmutableList; + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Stream; + +/** + * An immutable rose tree (unbounded branches) for generated code. + */ +public class TokenTree { + private static final TokenTree EMPTY = new TokenTree(); + + private final List children; + + protected TokenTree() { + this.children = ImmutableList.of(); + } + + private TokenTree(ImmutableList children) { + this.children = children; + } + + public static TokenTree empty() { + return EMPTY; + } + + public static TokenTree of(final TokenTree... trees) { + return new TokenTree(ImmutableList.copyOf(trees)); + } + + public static TokenTree of(final Stream trees) { + return new TokenTree(ImmutableList.copyOf(trees.iterator())); + } + + public static TokenTree of(final CharSequence... charSequences) { + return TokenTree.of(Arrays.stream(charSequences).map(Token::of)); + } + + public TokenTree surround(final TokenTree prefix, final TokenTree suffix) { + return TokenTree.of(prefix, this, suffix); + } + + public TokenTree braced() { + return surround(Token.of("{\n"), Token.of("\n}")); + } + + public TokenTree parenthesized() { + return surround(Token.of('('), Token.of(')')); + } + + public TokenTree angleBracketed() { + return surround(Token.of('<'), Token.of('>')); + } + + public TokenTree prepend(final TokenTree toPrepend) { + return TokenTree.of(toPrepend, this); + } + + public TokenTree append(final TokenTree toAppend) { + return TokenTree.of(this, toAppend); + } + + public TokenTree namespaced(final TokenTree namespace) { + return TokenTree.of(Token.of("namespace"), namespace, this.braced()); + } + + public TokenTree separated(final TokenTree separator) { + if (children.size() < 2) { + return this; + } + Stream separatedTokens = children + .stream() + .flatMap(tokenTree -> Stream.of(separator, tokenTree)) + .skip(1); + return new TokenTree(ImmutableList.copyOf(separatedTokens.iterator())); + } + + public TokenTree lineSeparated() { + return separated(Token.NEWLINE); + } + + @Override + public String toString() { + if (children.size() == 0) { + return ""; + } + + final StringBuilder builder = new StringBuilder(children.get(0).toString()); + children.stream().skip(1).forEach(tokenTree -> { + final String treeAsString = tokenTree.toString(); + if (!treeAsString.startsWith("\n")) { + builder.append(' '); + } + builder.append(treeAsString); + }); + return builder.toString(); + } +} diff --git a/smithy-dotnet/src/main/resources/META-INF/services/software.amazon.smithy.model.traits.TraitService b/smithy-dotnet/src/main/resources/META-INF/services/software.amazon.smithy.model.traits.TraitService new file mode 100644 index 0000000000..17be3441a8 --- /dev/null +++ b/smithy-dotnet/src/main/resources/META-INF/services/software.amazon.smithy.model.traits.TraitService @@ -0,0 +1,4 @@ +software.amazon.polymorph.traits.ReferenceTrait$Provider +software.amazon.polymorph.traits.PositionalTrait$Provider +software.amazon.polymorph.traits.ClientConfigTrait$Provider +software.amazon.polymorph.traits.DafnyUtf8BytesTrait$Provider diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpLexer.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpLexer.java new file mode 100644 index 0000000000..677b9e3c43 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpLexer.java @@ -0,0 +1,1301 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.antlr; + +// Generated from CSharpLexer.g4 by ANTLR 4.9.2 +import java.util.Stack; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class CSharpLexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + BYTE_ORDER_MARK=1, SINGLE_LINE_DOC_COMMENT=2, EMPTY_DELIMITED_DOC_COMMENT=3, + DELIMITED_DOC_COMMENT=4, SINGLE_LINE_COMMENT=5, DELIMITED_COMMENT=6, WHITESPACES=7, + SHARP=8, ABSTRACT=9, ADD=10, ALIAS=11, ARGLIST=12, AS=13, ASCENDING=14, + ASYNC=15, AWAIT=16, BASE=17, BOOL=18, BREAK=19, BY=20, BYTE=21, CASE=22, + CATCH=23, CHAR=24, CHECKED=25, CLASS=26, CONST=27, CONTINUE=28, DECIMAL=29, + DEFAULT=30, DELEGATE=31, DESCENDING=32, DO=33, DOUBLE=34, DYNAMIC=35, + ELSE=36, ENUM=37, EQUALS=38, EVENT=39, EXPLICIT=40, EXTERN=41, FALSE=42, + FINALLY=43, FIXED=44, FLOAT=45, FOR=46, FOREACH=47, FROM=48, GET=49, GOTO=50, + GROUP=51, IF=52, IMPLICIT=53, IN=54, INT=55, INTERFACE=56, INTERNAL=57, + INTO=58, IS=59, JOIN=60, LET=61, LOCK=62, LONG=63, NAMEOF=64, NAMESPACE=65, + NEW=66, NULL_=67, OBJECT=68, ON=69, OPERATOR=70, ORDERBY=71, OUT=72, OVERRIDE=73, + PARAMS=74, PARTIAL=75, PRIVATE=76, PROTECTED=77, PUBLIC=78, READONLY=79, + REF=80, REMOVE=81, RETURN=82, SBYTE=83, SEALED=84, SELECT=85, SET=86, + SHORT=87, SIZEOF=88, STACKALLOC=89, STATIC=90, STRING=91, STRUCT=92, SWITCH=93, + THIS=94, THROW=95, TRUE=96, TRY=97, TYPEOF=98, UINT=99, ULONG=100, UNCHECKED=101, + UNMANAGED=102, UNSAFE=103, USHORT=104, USING=105, VAR=106, VIRTUAL=107, + VOID=108, VOLATILE=109, WHEN=110, WHERE=111, WHILE=112, YIELD=113, IDENTIFIER=114, + LITERAL_ACCESS=115, INTEGER_LITERAL=116, HEX_INTEGER_LITERAL=117, BIN_INTEGER_LITERAL=118, + REAL_LITERAL=119, CHARACTER_LITERAL=120, REGULAR_STRING=121, VERBATIUM_STRING=122, + INTERPOLATED_REGULAR_STRING_START=123, INTERPOLATED_VERBATIUM_STRING_START=124, + OPEN_BRACE=125, CLOSE_BRACE=126, OPEN_BRACKET=127, CLOSE_BRACKET=128, + OPEN_PARENS=129, CLOSE_PARENS=130, DOT=131, COMMA=132, COLON=133, SEMICOLON=134, + PLUS=135, MINUS=136, STAR=137, DIV=138, PERCENT=139, AMP=140, BITWISE_OR=141, + CARET=142, BANG=143, TILDE=144, ASSIGNMENT=145, LT=146, GT=147, INTERR=148, + DOUBLE_COLON=149, OP_COALESCING=150, OP_INC=151, OP_DEC=152, OP_AND=153, + OP_OR=154, OP_PTR=155, OP_EQ=156, OP_NE=157, OP_LE=158, OP_GE=159, OP_ADD_ASSIGNMENT=160, + OP_SUB_ASSIGNMENT=161, OP_MULT_ASSIGNMENT=162, OP_DIV_ASSIGNMENT=163, + OP_MOD_ASSIGNMENT=164, OP_AND_ASSIGNMENT=165, OP_OR_ASSIGNMENT=166, OP_XOR_ASSIGNMENT=167, + OP_LEFT_SHIFT=168, OP_LEFT_SHIFT_ASSIGNMENT=169, OP_COALESCING_ASSIGNMENT=170, + OP_RANGE=171, DOUBLE_CURLY_INSIDE=172, OPEN_BRACE_INSIDE=173, REGULAR_CHAR_INSIDE=174, + VERBATIUM_DOUBLE_QUOTE_INSIDE=175, DOUBLE_QUOTE_INSIDE=176, REGULAR_STRING_INSIDE=177, + VERBATIUM_INSIDE_STRING=178, CLOSE_BRACE_INSIDE=179, FORMAT_STRING=180, + DIRECTIVE_WHITESPACES=181, DIGITS=182, DEFINE=183, UNDEF=184, ELIF=185, + ENDIF=186, LINE=187, ERROR=188, WARNING=189, REGION=190, ENDREGION=191, + PRAGMA=192, NULLABLE=193, DIRECTIVE_HIDDEN=194, CONDITIONAL_SYMBOL=195, + DIRECTIVE_NEW_LINE=196, TEXT=197, DOUBLE_CURLY_CLOSE_INSIDE=198; + public static final int + COMMENTS_CHANNEL=2, DIRECTIVE=3; + public static final int + INTERPOLATION_STRING=1, INTERPOLATION_FORMAT=2, DIRECTIVE_MODE=3, DIRECTIVE_TEXT=4; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", "COMMENTS_CHANNEL", "DIRECTIVE" + }; + + public static String[] modeNames = { + "DEFAULT_MODE", "INTERPOLATION_STRING", "INTERPOLATION_FORMAT", "DIRECTIVE_MODE", + "DIRECTIVE_TEXT" + }; + + private static String[] makeRuleNames() { + return new String[] { + "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT", "EMPTY_DELIMITED_DOC_COMMENT", + "DELIMITED_DOC_COMMENT", "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", + "WHITESPACES", "SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS", + "ASCENDING", "ASYNC", "AWAIT", "BASE", "BOOL", "BREAK", "BY", "BYTE", + "CASE", "CATCH", "CHAR", "CHECKED", "CLASS", "CONST", "CONTINUE", "DECIMAL", + "DEFAULT", "DELEGATE", "DESCENDING", "DO", "DOUBLE", "DYNAMIC", "ELSE", + "ENUM", "EQUALS", "EVENT", "EXPLICIT", "EXTERN", "FALSE", "FINALLY", + "FIXED", "FLOAT", "FOR", "FOREACH", "FROM", "GET", "GOTO", "GROUP", "IF", + "IMPLICIT", "IN", "INT", "INTERFACE", "INTERNAL", "INTO", "IS", "JOIN", + "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE", "NEW", "NULL_", "OBJECT", + "ON", "OPERATOR", "ORDERBY", "OUT", "OVERRIDE", "PARAMS", "PARTIAL", + "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", "REF", "REMOVE", "RETURN", + "SBYTE", "SEALED", "SELECT", "SET", "SHORT", "SIZEOF", "STACKALLOC", + "STATIC", "STRING", "STRUCT", "SWITCH", "THIS", "THROW", "TRUE", "TRY", + "TYPEOF", "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE", "USHORT", + "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE", "WHEN", "WHERE", "WHILE", + "YIELD", "IDENTIFIER", "LITERAL_ACCESS", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", + "BIN_INTEGER_LITERAL", "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING", + "VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START", "INTERPOLATED_VERBATIUM_STRING_START", + "OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS", + "CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON", "PLUS", "MINUS", + "STAR", "DIV", "PERCENT", "AMP", "BITWISE_OR", "CARET", "BANG", "TILDE", + "ASSIGNMENT", "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING", + "OP_INC", "OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ", "OP_NE", "OP_LE", + "OP_GE", "OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT", "OP_MULT_ASSIGNMENT", + "OP_DIV_ASSIGNMENT", "OP_MOD_ASSIGNMENT", "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", + "OP_XOR_ASSIGNMENT", "OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT", + "OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE", "REGULAR_CHAR_INSIDE", + "VERBATIUM_DOUBLE_QUOTE_INSIDE", "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", + "VERBATIUM_INSIDE_STRING", "DOUBLE_CURLY_CLOSE_INSIDE", "CLOSE_BRACE_INSIDE", + "FORMAT_STRING", "DIRECTIVE_WHITESPACES", "DIGITS", "DIRECTIVE_TRUE", + "DIRECTIVE_FALSE", "DEFINE", "UNDEF", "DIRECTIVE_IF", "ELIF", "DIRECTIVE_ELSE", + "ENDIF", "LINE", "ERROR", "WARNING", "REGION", "ENDREGION", "PRAGMA", + "NULLABLE", "DIRECTIVE_DEFAULT", "DIRECTIVE_HIDDEN", "DIRECTIVE_OPEN_PARENS", + "DIRECTIVE_CLOSE_PARENS", "DIRECTIVE_BANG", "DIRECTIVE_OP_EQ", "DIRECTIVE_OP_NE", + "DIRECTIVE_OP_AND", "DIRECTIVE_OP_OR", "DIRECTIVE_STRING", "CONDITIONAL_SYMBOL", + "DIRECTIVE_SINGLE_LINE_COMMENT", "DIRECTIVE_NEW_LINE", "TEXT", "TEXT_NEW_LINE", + "InputCharacter", "NewLineCharacter", "IntegerTypeSuffix", "ExponentPart", + "CommonCharacter", "SimpleEscapeSequence", "HexEscapeSequence", "NewLine", + "Whitespace", "UnicodeClassZS", "IdentifierOrKeyword", "IdentifierStartCharacter", + "IdentifierPartCharacter", "LetterCharacter", "DecimalDigitCharacter", + "ConnectingCharacter", "CombiningCharacter", "FormattingCharacter", "UnicodeEscapeSequence", + "HexDigit", "UnicodeClassLU", "UnicodeClassLL", "UnicodeClassLT", "UnicodeClassLM", + "UnicodeClassLO", "UnicodeClassNL", "UnicodeClassMN", "UnicodeClassMC", + "UnicodeClassCF", "UnicodeClassPC", "UnicodeClassND" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "'\u00EF\u00BB\u00BF'", null, "'/***/'", null, null, null, null, + "'#'", "'abstract'", "'add'", "'alias'", "'__arglist'", "'as'", "'ascending'", + "'async'", "'await'", "'base'", "'bool'", "'break'", "'by'", "'byte'", + "'case'", "'catch'", "'char'", "'checked'", "'class'", "'const'", "'continue'", + "'decimal'", "'default'", "'delegate'", "'descending'", "'do'", "'double'", + "'dynamic'", "'else'", "'enum'", "'equals'", "'event'", "'explicit'", + "'extern'", "'false'", "'finally'", "'fixed'", "'float'", "'for'", "'foreach'", + "'from'", "'get'", "'goto'", "'group'", "'if'", "'implicit'", "'in'", + "'int'", "'interface'", "'internal'", "'into'", "'is'", "'join'", "'let'", + "'lock'", "'long'", "'nameof'", "'namespace'", "'new'", "'null'", "'object'", + "'on'", "'operator'", "'orderby'", "'out'", "'override'", "'params'", + "'partial'", "'private'", "'protected'", "'public'", "'readonly'", "'ref'", + "'remove'", "'return'", "'sbyte'", "'sealed'", "'select'", "'set'", "'short'", + "'sizeof'", "'stackalloc'", "'static'", "'string'", "'struct'", "'switch'", + "'this'", "'throw'", "'true'", "'try'", "'typeof'", "'uint'", "'ulong'", + "'unchecked'", "'unmanaged'", "'unsafe'", "'ushort'", "'using'", "'var'", + "'virtual'", "'void'", "'volatile'", "'when'", "'where'", "'while'", + "'yield'", null, null, null, null, null, null, null, null, null, null, + null, "'{'", "'}'", "'['", "']'", "'('", "')'", "'.'", "','", "':'", + "';'", "'+'", "'-'", "'*'", "'/'", "'%'", "'&'", "'|'", "'^'", "'!'", + "'~'", "'='", "'<'", "'>'", "'?'", "'::'", "'??'", "'++'", "'--'", "'&&'", + "'||'", "'->'", "'=='", "'!='", "'<='", "'>='", "'+='", "'-='", "'*='", + "'/='", "'%='", "'&='", "'|='", "'^='", "'<<'", "'<<='", "'??='", "'..'", + "'{{'", null, null, null, null, null, null, null, null, null, null, "'define'", + "'undef'", "'elif'", "'endif'", "'line'", null, null, null, null, null, + null, "'hidden'", null, null, null, "'}}'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT", "EMPTY_DELIMITED_DOC_COMMENT", + "DELIMITED_DOC_COMMENT", "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", + "WHITESPACES", "SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS", + "ASCENDING", "ASYNC", "AWAIT", "BASE", "BOOL", "BREAK", "BY", "BYTE", + "CASE", "CATCH", "CHAR", "CHECKED", "CLASS", "CONST", "CONTINUE", "DECIMAL", + "DEFAULT", "DELEGATE", "DESCENDING", "DO", "DOUBLE", "DYNAMIC", "ELSE", + "ENUM", "EQUALS", "EVENT", "EXPLICIT", "EXTERN", "FALSE", "FINALLY", + "FIXED", "FLOAT", "FOR", "FOREACH", "FROM", "GET", "GOTO", "GROUP", "IF", + "IMPLICIT", "IN", "INT", "INTERFACE", "INTERNAL", "INTO", "IS", "JOIN", + "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE", "NEW", "NULL_", "OBJECT", + "ON", "OPERATOR", "ORDERBY", "OUT", "OVERRIDE", "PARAMS", "PARTIAL", + "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", "REF", "REMOVE", "RETURN", + "SBYTE", "SEALED", "SELECT", "SET", "SHORT", "SIZEOF", "STACKALLOC", + "STATIC", "STRING", "STRUCT", "SWITCH", "THIS", "THROW", "TRUE", "TRY", + "TYPEOF", "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE", "USHORT", + "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE", "WHEN", "WHERE", "WHILE", + "YIELD", "IDENTIFIER", "LITERAL_ACCESS", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", + "BIN_INTEGER_LITERAL", "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING", + "VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START", "INTERPOLATED_VERBATIUM_STRING_START", + "OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS", + "CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON", "PLUS", "MINUS", + "STAR", "DIV", "PERCENT", "AMP", "BITWISE_OR", "CARET", "BANG", "TILDE", + "ASSIGNMENT", "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING", + "OP_INC", "OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ", "OP_NE", "OP_LE", + "OP_GE", "OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT", "OP_MULT_ASSIGNMENT", + "OP_DIV_ASSIGNMENT", "OP_MOD_ASSIGNMENT", "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", + "OP_XOR_ASSIGNMENT", "OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT", + "OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE", "REGULAR_CHAR_INSIDE", + "VERBATIUM_DOUBLE_QUOTE_INSIDE", "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", + "VERBATIUM_INSIDE_STRING", "CLOSE_BRACE_INSIDE", "FORMAT_STRING", "DIRECTIVE_WHITESPACES", + "DIGITS", "DEFINE", "UNDEF", "ELIF", "ENDIF", "LINE", "ERROR", "WARNING", + "REGION", "ENDREGION", "PRAGMA", "NULLABLE", "DIRECTIVE_HIDDEN", "CONDITIONAL_SYMBOL", + "DIRECTIVE_NEW_LINE", "TEXT", "DOUBLE_CURLY_CLOSE_INSIDE" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + 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] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + private int interpolatedStringLevel; + private Stack interpolatedVerbatiums = new Stack(); + private Stack curlyLevels = new Stack(); + private boolean verbatium; + + + public CSharpLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "CSharpLexer.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + @Override + public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { + switch (ruleIndex) { + case 122: + INTERPOLATED_REGULAR_STRING_START_action((RuleContext)_localctx, actionIndex); + break; + case 123: + INTERPOLATED_VERBATIUM_STRING_START_action((RuleContext)_localctx, actionIndex); + break; + case 124: + OPEN_BRACE_action((RuleContext)_localctx, actionIndex); + break; + case 125: + CLOSE_BRACE_action((RuleContext)_localctx, actionIndex); + break; + case 132: + COLON_action((RuleContext)_localctx, actionIndex); + break; + case 172: + OPEN_BRACE_INSIDE_action((RuleContext)_localctx, actionIndex); + break; + case 175: + DOUBLE_QUOTE_INSIDE_action((RuleContext)_localctx, actionIndex); + break; + case 179: + CLOSE_BRACE_INSIDE_action((RuleContext)_localctx, actionIndex); + break; + } + } + private void INTERPOLATED_REGULAR_STRING_START_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 0: + interpolatedStringLevel++; interpolatedVerbatiums.push(false); verbatium = false; + break; + } + } + private void INTERPOLATED_VERBATIUM_STRING_START_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 1: + interpolatedStringLevel++; interpolatedVerbatiums.push(true); verbatium = true; + break; + } + } + private void OPEN_BRACE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 2: + + if (interpolatedStringLevel > 0) + { + curlyLevels.push(curlyLevels.pop() + 1); + } + break; + } + } + private void CLOSE_BRACE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 3: + + if (interpolatedStringLevel > 0) + { + curlyLevels.push(curlyLevels.pop() - 1); + if (curlyLevels.peek() == 0) + { + curlyLevels.pop(); + skip(); + popMode(); + } + } + + break; + } + } + private void COLON_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 4: + + if (interpolatedStringLevel > 0) + { + int ind = 1; + boolean switchToFormatString = true; + while ((char)_input.LA(ind) != '}') + { + if (_input.LA(ind) == ':' || _input.LA(ind) == ')') + { + switchToFormatString = false; + break; + } + ind++; + } + if (switchToFormatString) + { + mode(INTERPOLATION_FORMAT); + } + } + + break; + } + } + private void OPEN_BRACE_INSIDE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 5: + curlyLevels.push(1); + break; + } + } + private void DOUBLE_QUOTE_INSIDE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 6: + interpolatedStringLevel--; interpolatedVerbatiums.pop(); + verbatium = (interpolatedVerbatiums.size() > 0 ? interpolatedVerbatiums.peek() : false); + break; + } + } + private void CLOSE_BRACE_INSIDE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 7: + curlyLevels.pop(); + break; + } + } + @Override + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 173: + return REGULAR_CHAR_INSIDE_sempred((RuleContext)_localctx, predIndex); + case 174: + return VERBATIUM_DOUBLE_QUOTE_INSIDE_sempred((RuleContext)_localctx, predIndex); + case 176: + return REGULAR_STRING_INSIDE_sempred((RuleContext)_localctx, predIndex); + case 177: + return VERBATIUM_INSIDE_STRING_sempred((RuleContext)_localctx, predIndex); + } + return true; + } + private boolean REGULAR_CHAR_INSIDE_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return !verbatium ; + } + return true; + } + private boolean VERBATIUM_DOUBLE_QUOTE_INSIDE_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return verbatium ; + } + return true; + } + private boolean REGULAR_STRING_INSIDE_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 2: + return !verbatium ; + } + return true; + } + private boolean VERBATIUM_INSIDE_STRING_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 3: + return verbatium ; + } + return true; + } + + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u00c8\u0816\b\1\b"+ + "\1\b\1\b\1\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\4"+ + "F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\t"+ + "Q\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\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\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\4\u00ef\t\u00ef"+ + "\4\u00f0\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4"+ + "\t\u00f4\4\u00f5\t\u00f5\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\7\3\u01f9"+ + "\n\3\f\3\16\3\u01fc\13\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\7\5\u020e\n\5\f\5\16\5\u0211\13\5\3\5\3\5\3\5\3\5\3"+ + "\5\3\6\3\6\3\6\3\6\7\6\u021c\n\6\f\6\16\6\u021f\13\6\3\6\3\6\3\7\3\7\3"+ + "\7\3\7\7\7\u0227\n\7\f\7\16\7\u022a\13\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\6"+ + "\b\u0233\n\b\r\b\16\b\u0234\3\b\3\b\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3"+ + "\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\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\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\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\20\3\21\3\21\3"+ + "\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3"+ + "\24\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3"+ + "\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\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\32\3\33\3\33\3\33\3\33\3"+ + "\33\3\33\3\34\3\34\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\36\3\36\3\36\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\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\60\3\60\3\60\3\60\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\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3"+ + "\64\3\64\3\65\3\65\3\65\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3"+ + "\67\3\67\3\67\38\38\38\38\39\39\39\39\39\39\39\39\39\39\3:\3:\3:\3:\3"+ + ":\3:\3:\3:\3:\3;\3;\3;\3;\3;\3<\3<\3<\3=\3=\3=\3=\3=\3>\3>\3>\3>\3?\3"+ + "?\3?\3?\3?\3@\3@\3@\3@\3@\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3B\3B\3"+ + "B\3B\3B\3C\3C\3C\3C\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E\3E\3E\3F\3F\3F\3G\3"+ + "G\3G\3G\3G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3J\3J\3J\3"+ + "J\3J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L\3L\3L\3L\3L\3M\3M\3"+ + "M\3M\3M\3M\3M\3M\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3O\3O\3"+ + "P\3P\3P\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3R\3R\3R\3S\3S\3S\3"+ + "S\3S\3S\3S\3T\3T\3T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3"+ + "V\3W\3W\3W\3W\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3"+ + "Z\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3]\3"+ + "]\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3^\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3"+ + "`\3a\3a\3a\3a\3a\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3e\3"+ + "e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3g\3g\3g\3g\3g\3g\3g\3g\3"+ + "g\3g\3h\3h\3h\3h\3h\3h\3h\3i\3i\3i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3k\3"+ + "k\3k\3k\3l\3l\3l\3l\3l\3l\3l\3l\3m\3m\3m\3m\3m\3n\3n\3n\3n\3n\3n\3n\3"+ + "n\3n\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3q\3q\3q\3q\3q\3q\3r\3r\3r\3r\3"+ + "r\3r\3s\5s\u04e1\ns\3s\3s\3t\3t\7t\u04e7\nt\ft\16t\u04ea\13t\3t\7t\u04ed"+ + "\nt\ft\16t\u04f0\13t\3t\5t\u04f3\nt\3t\3t\5t\u04f7\nt\3t\3t\3u\3u\7u\u04fd"+ + "\nu\fu\16u\u0500\13u\3u\7u\u0503\nu\fu\16u\u0506\13u\3u\5u\u0509\nu\3"+ + "v\3v\3v\7v\u050e\nv\fv\16v\u0511\13v\3v\6v\u0514\nv\rv\16v\u0515\3v\5"+ + "v\u0519\nv\3w\3w\3w\7w\u051e\nw\fw\16w\u0521\13w\3w\6w\u0524\nw\rw\16"+ + "w\u0525\3w\5w\u0529\nw\3x\3x\7x\u052d\nx\fx\16x\u0530\13x\3x\7x\u0533"+ + "\nx\fx\16x\u0536\13x\5x\u0538\nx\3x\3x\3x\7x\u053d\nx\fx\16x\u0540\13"+ + "x\3x\7x\u0543\nx\fx\16x\u0546\13x\3x\5x\u0549\nx\3x\5x\u054c\nx\3x\3x"+ + "\7x\u0550\nx\fx\16x\u0553\13x\3x\7x\u0556\nx\fx\16x\u0559\13x\3x\3x\3"+ + "x\5x\u055e\nx\5x\u0560\nx\5x\u0562\nx\3y\3y\3y\5y\u0567\ny\3y\3y\3z\3"+ + "z\3z\7z\u056e\nz\fz\16z\u0571\13z\3z\3z\3{\3{\3{\3{\3{\3{\7{\u057b\n{"+ + "\f{\16{\u057e\13{\3{\3{\3|\3|\3|\3|\3|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3"+ + "~\3~\3~\3\177\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\u0088\3\u0088\3\u0089\3\u0089\3\u008a\3\u008a\3\u008b"+ + "\3\u008b\3\u008c\3\u008c\3\u008d\3\u008d\3\u008e\3\u008e\3\u008f\3\u008f"+ + "\3\u0090\3\u0090\3\u0091\3\u0091\3\u0092\3\u0092\3\u0093\3\u0093\3\u0094"+ + "\3\u0094\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097"+ + "\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099\3\u009a\3\u009a\3\u009a"+ + "\3\u009b\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c\3\u009d\3\u009d\3\u009d"+ + "\3\u009e\3\u009e\3\u009e\3\u009f\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0"+ + "\3\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3\3\u00a3"+ + "\3\u00a4\3\u00a4\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6"+ + "\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a9\3\u00a9\3\u00a9"+ + "\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ac"+ + "\3\u00ac\3\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae\3\u00ae\3\u00ae"+ + "\3\u00ae\3\u00ae\3\u00af\3\u00af\3\u00af\3\u00b0\3\u00b0\3\u00b0\3\u00b0"+ + "\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2\6\u00b2\u0622"+ + "\n\u00b2\r\u00b2\16\u00b2\u0623\3\u00b3\3\u00b3\6\u00b3\u0628\n\u00b3"+ + "\r\u00b3\16\u00b3\u0629\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5"+ + "\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b6\6\u00b6\u0638\n\u00b6"+ + "\r\u00b6\16\u00b6\u0639\3\u00b7\6\u00b7\u063d\n\u00b7\r\u00b7\16\u00b7"+ + "\u063e\3\u00b7\3\u00b7\3\u00b8\6\u00b8\u0644\n\u00b8\r\u00b8\16\u00b8"+ + "\u0645\3\u00b8\3\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9"+ + "\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba"+ + "\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb"+ + "\3\u00bb\3\u00bb\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc"+ + "\3\u00bc\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be"+ + "\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf"+ + "\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0"+ + "\3\u00c0\3\u00c0\3\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1"+ + "\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\6\u00c2"+ + "\u0697\n\u00c2\r\u00c2\16\u00c2\u0698\3\u00c2\3\u00c2\3\u00c2\3\u00c3"+ + "\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\6\u00c3"+ + "\u06a7\n\u00c3\r\u00c3\16\u00c3\u06a8\3\u00c3\3\u00c3\3\u00c3\3\u00c4"+ + "\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\7\u00c4\u06b6"+ + "\n\u00c4\f\u00c4\16\u00c4\u06b9\13\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c5"+ + "\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5"+ + "\3\u00c5\7\u00c5\u06c9\n\u00c5\f\u00c5\16\u00c5\u06cc\13\u00c5\3\u00c5"+ + "\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6"+ + "\3\u00c6\6\u00c6\u06d9\n\u00c6\r\u00c6\16\u00c6\u06da\3\u00c6\3\u00c6"+ + "\3\u00c6\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7"+ + "\3\u00c7\3\u00c7\6\u00c7\u06ea\n\u00c7\r\u00c7\16\u00c7\u06eb\3\u00c7"+ + "\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8"+ + "\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9"+ + "\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca"+ + "\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cc\3\u00cc\3\u00cc\3\u00cc"+ + "\3\u00cc\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00ce\3\u00ce"+ + "\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf"+ + "\3\u00cf\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d1\3\u00d1"+ + "\7\u00d1\u072e\n\u00d1\f\u00d1\16\u00d1\u0731\13\u00d1\3\u00d1\3\u00d1"+ + "\3\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d3\3\u00d3"+ + "\3\u00d3\3\u00d3\7\u00d3\u0740\n\u00d3\f\u00d3\16\u00d3\u0743\13\u00d3"+ + "\3\u00d3\3\u00d3\3\u00d3\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d5"+ + "\6\u00d5\u074e\n\u00d5\r\u00d5\16\u00d5\u074f\3\u00d5\3\u00d5\3\u00d6"+ + "\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d7\3\u00d7\3\u00d8\3\u00d8"+ + "\3\u00d9\5\u00d9\u075f\n\u00d9\3\u00d9\3\u00d9\5\u00d9\u0763\n\u00d9\3"+ + "\u00d9\5\u00d9\u0766\n\u00d9\3\u00da\3\u00da\5\u00da\u076a\n\u00da\3\u00da"+ + "\3\u00da\7\u00da\u076e\n\u00da\f\u00da\16\u00da\u0771\13\u00da\3\u00da"+ + "\7\u00da\u0774\n\u00da\f\u00da\16\u00da\u0777\13\u00da\3\u00db\3\u00db"+ + "\3\u00db\5\u00db\u077c\n\u00db\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc"+ + "\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc"+ + "\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\5\u00dc"+ + "\u0794\n\u00dc\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd"+ + "\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd"+ + "\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd"+ + "\5\u00dd\u07af\n\u00dd\3\u00de\3\u00de\3\u00de\5\u00de\u07b4\n\u00de\3"+ + "\u00df\3\u00df\5\u00df\u07b8\n\u00df\3\u00e0\3\u00e0\3\u00e1\3\u00e1\7"+ + "\u00e1\u07be\n\u00e1\f\u00e1\16\u00e1\u07c1\13\u00e1\3\u00e2\3\u00e2\5"+ + "\u00e2\u07c5\n\u00e2\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\5\u00e3\u07cc"+ + "\n\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\5\u00e4"+ + "\u07d5\n\u00e4\3\u00e5\3\u00e5\5\u00e5\u07d9\n\u00e5\3\u00e6\3\u00e6\5"+ + "\u00e6\u07dd\n\u00e6\3\u00e7\3\u00e7\3\u00e7\5\u00e7\u07e2\n\u00e7\3\u00e8"+ + "\3\u00e8\5\u00e8\u07e6\n\u00e8\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9"+ + "\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9"+ + "\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\5\u00e9\u07fc\n\u00e9"+ + "\3\u00ea\5\u00ea\u07ff\n\u00ea\3\u00eb\3\u00eb\3\u00ec\3\u00ec\3\u00ed"+ + "\3\u00ed\3\u00ee\3\u00ee\3\u00ef\3\u00ef\3\u00f0\3\u00f0\3\u00f1\3\u00f1"+ + "\3\u00f2\3\u00f2\3\u00f3\3\u00f3\3\u00f4\3\u00f4\3\u00f5\3\u00f5\4\u020f"+ + "\u0228\2\u00f6\7\3\t\4\13\5\r\6\17\7\21\b\23\t\25\n\27\13\31\f\33\r\35"+ + "\16\37\17!\20#\21%\22\'\23)\24+\25-\26/\27\61\30\63\31\65\32\67\339\34"+ + ";\35=\36?\37A C!E\"G#I$K%M&O\'Q(S)U*W+Y,[-]._/a\60c\61e\62g\63i\64k\65"+ + "m\66o\67q8s9u:w;y<{=}>\177?\u0081@\u0083A\u0085B\u0087C\u0089D\u008bE"+ + "\u008dF\u008fG\u0091H\u0093I\u0095J\u0097K\u0099L\u009bM\u009dN\u009f"+ + "O\u00a1P\u00a3Q\u00a5R\u00a7S\u00a9T\u00abU\u00adV\u00afW\u00b1X\u00b3"+ + "Y\u00b5Z\u00b7[\u00b9\\\u00bb]\u00bd^\u00bf_\u00c1`\u00c3a\u00c5b\u00c7"+ + "c\u00c9d\u00cbe\u00cdf\u00cfg\u00d1h\u00d3i\u00d5j\u00d7k\u00d9l\u00db"+ + "m\u00ddn\u00dfo\u00e1p\u00e3q\u00e5r\u00e7s\u00e9t\u00ebu\u00edv\u00ef"+ + "w\u00f1x\u00f3y\u00f5z\u00f7{\u00f9|\u00fb}\u00fd~\u00ff\177\u0101\u0080"+ + "\u0103\u0081\u0105\u0082\u0107\u0083\u0109\u0084\u010b\u0085\u010d\u0086"+ + "\u010f\u0087\u0111\u0088\u0113\u0089\u0115\u008a\u0117\u008b\u0119\u008c"+ + "\u011b\u008d\u011d\u008e\u011f\u008f\u0121\u0090\u0123\u0091\u0125\u0092"+ + "\u0127\u0093\u0129\u0094\u012b\u0095\u012d\u0096\u012f\u0097\u0131\u0098"+ + "\u0133\u0099\u0135\u009a\u0137\u009b\u0139\u009c\u013b\u009d\u013d\u009e"+ + "\u013f\u009f\u0141\u00a0\u0143\u00a1\u0145\u00a2\u0147\u00a3\u0149\u00a4"+ + "\u014b\u00a5\u014d\u00a6\u014f\u00a7\u0151\u00a8\u0153\u00a9\u0155\u00aa"+ + "\u0157\u00ab\u0159\u00ac\u015b\u00ad\u015d\u00ae\u015f\u00af\u0161\u00b0"+ + "\u0163\u00b1\u0165\u00b2\u0167\u00b3\u0169\u00b4\u016b\u00c8\u016d\u00b5"+ + "\u016f\u00b6\u0171\u00b7\u0173\u00b8\u0175\2\u0177\2\u0179\u00b9\u017b"+ + "\u00ba\u017d\2\u017f\u00bb\u0181\2\u0183\u00bc\u0185\u00bd\u0187\u00be"+ + "\u0189\u00bf\u018b\u00c0\u018d\u00c1\u018f\u00c2\u0191\u00c3\u0193\2\u0195"+ + "\u00c4\u0197\2\u0199\2\u019b\2\u019d\2\u019f\2\u01a1\2\u01a3\2\u01a5\2"+ + "\u01a7\u00c5\u01a9\2\u01ab\u00c6\u01ad\u00c7\u01af\2\u01b1\2\u01b3\2\u01b5"+ + "\2\u01b7\2\u01b9\2\u01bb\2\u01bd\2\u01bf\2\u01c1\2\u01c3\2\u01c5\2\u01c7"+ + "\2\u01c9\2\u01cb\2\u01cd\2\u01cf\2\u01d1\2\u01d3\2\u01d5\2\u01d7\2\u01d9"+ + "\2\u01db\2\u01dd\2\u01df\2\u01e1\2\u01e3\2\u01e5\2\u01e7\2\u01e9\2\u01eb"+ + "\2\u01ed\2\7\2\3\4\5\6!\3\2\61\61\3\2\62;\4\2ZZzz\4\2DDdd\3\2\62\63\b"+ + "\2FFHHOOffhhoo\b\2\f\f\17\17))^^\u0087\u0087\u202a\u202b\b\2\f\f\17\17"+ + "$$^^\u0087\u0087\u202a\u202b\3\2$$\5\2$$^^}}\4\2$$}}\3\2\177\177\7\2\f"+ + "\f\17\17$$\u0087\u0087\u202a\u202b\6\2\f\f\17\17\u0087\u0087\u202a\u202b"+ + "\4\2NNnn\4\2WWww\4\2GGgg\4\2--//\4\2\13\13\r\16\13\2\"\"\u00a2\u00a2\u1682"+ + "\u1682\u1810\u1810\u2002\u2008\u200a\u200c\u2031\u2031\u2061\u2061\u3002"+ + "\u3002\5\2\62;CHchT\2C\\\u00c2\u00d8\u00da\u00e0\u0102\u0138\u013b\u0149"+ + "\u014c\u017f\u0183\u0184\u0186\u018d\u0190\u0193\u0195\u0196\u0198\u019a"+ + "\u019e\u019f\u01a1\u01a2\u01a4\u01ab\u01ae\u01b5\u01b7\u01be\u01c6\u01cf"+ + "\u01d1\u01dd\u01e0\u01f0\u01f3\u01f6\u01f8\u01fa\u01fc\u0234\u023c\u023d"+ + "\u023f\u0240\u0243\u0248\u024a\u0250\u0372\u0374\u0378\u0381\u0388\u038c"+ + "\u038e\u03a3\u03a5\u03ad\u03d1\u03d6\u03da\u03f0\u03f6\u03f9\u03fb\u03fc"+ + "\u03ff\u0431\u0462\u0482\u048c\u04cf\u04d2\u0530\u0533\u0558\u10a2\u10c7"+ + "\u10c9\u10cf\u1e02\u1e96\u1ea0\u1f00\u1f0a\u1f11\u1f1a\u1f1f\u1f2a\u1f31"+ + "\u1f3a\u1f41\u1f4a\u1f4f\u1f5b\u1f61\u1f6a\u1f71\u1fba\u1fbd\u1fca\u1fcd"+ + "\u1fda\u1fdd\u1fea\u1fee\u1ffa\u1ffd\u2104\u2109\u210d\u210f\u2112\u2114"+ + "\u2117\u211f\u2126\u212f\u2132\u2135\u2140\u2141\u2147\u2185\u2c02\u2c30"+ + "\u2c62\u2c66\u2c69\u2c72\u2c74\u2c77\u2c80\u2c82\u2c84\u2ce4\u2ced\u2cef"+ + "\u2cf4\ua642\ua644\ua66e\ua682\ua69c\ua724\ua730\ua734\ua770\ua77b\ua788"+ + "\ua78d\ua78f\ua792\ua794\ua798\ua7af\ua7b2\ua7b3\uff23\uff3cS\2c|\u00b7"+ + "\u00f8\u00fa\u0101\u0103\u0179\u017c\u0182\u0185\u0187\u018a\u0194\u0197"+ + "\u019d\u01a0\u01a3\u01a5\u01a7\u01aa\u01af\u01b2\u01b6\u01b8\u01c1\u01c8"+ + "\u01ce\u01d0\u01f5\u01f7\u01fb\u01fd\u023b\u023e\u0244\u0249\u0295\u0297"+ + "\u02b1\u0373\u0375\u0379\u037f\u0392\u03d0\u03d2\u03d3\u03d7\u03d9\u03db"+ + "\u03f5\u03f7\u0461\u0463\u0483\u048d\u04c1\u04c4\u0531\u0563\u0589\u1d02"+ + "\u1d2d\u1d6d\u1d79\u1d7b\u1d9c\u1e03\u1e9f\u1ea1\u1f09\u1f12\u1f17\u1f22"+ + "\u1f29\u1f32\u1f39\u1f42\u1f47\u1f52\u1f59\u1f62\u1f69\u1f72\u1f7f\u1f82"+ + "\u1f89\u1f92\u1f99\u1fa2\u1fa9\u1fb2\u1fb6\u1fb8\u1fb9\u1fc0\u1fc6\u1fc8"+ + "\u1fc9\u1fd2\u1fd5\u1fd8\u1fd9\u1fe2\u1fe9\u1ff4\u1ff6\u1ff8\u1ff9\u210c"+ + "\u2115\u2131\u213b\u213e\u213f\u2148\u214b\u2150\u2186\u2c32\u2c60\u2c63"+ + "\u2c6e\u2c73\u2c7d\u2c83\u2cee\u2cf0\u2cf5\u2d02\u2d27\u2d29\u2d2f\ua643"+ + "\ua66f\ua683\ua69d\ua725\ua733\ua735\ua77a\ua77c\ua77e\ua781\ua789\ua78e"+ + "\ua790\ua793\ua797\ua799\ua7ab\ua7fc\uab5c\uab66\uab67\ufb02\ufb08\ufb15"+ + "\ufb19\uff43\uff5c\b\2\u01c7\u01cd\u01f4\u1f91\u1f9a\u1fa1\u1faa\u1fb1"+ + "\u1fbe\u1fce\u1ffe\u1ffe#\2\u02b2\u02c3\u02c8\u02d3\u02e2\u02e6\u02ee"+ + "\u02f0\u0376\u037c\u055b\u0642\u06e7\u06e8\u07f6\u07f7\u07fc\u081c\u0826"+ + "\u082a\u0973\u0e48\u0ec8\u10fe\u17d9\u1845\u1aa9\u1c7f\u1d2e\u1d6c\u1d7a"+ + "\u1dc1\u2073\u2081\u2092\u209e\u2c7e\u2c7f\u2d71\u2e31\u3007\u3037\u303d"+ + "\u3100\ua017\ua4ff\ua60e\ua681\ua69e\ua69f\ua719\ua721\ua772\ua78a\ua7fa"+ + "\ua7fb\ua9d1\ua9e8\uaa72\uaadf\uaaf5\uaaf6\uab5e\uab61\uff72\uffa1\u00ec"+ + "\2\u00ac\u00bc\u01bd\u01c5\u0296\u05ec\u05f2\u05f4\u0622\u0641\u0643\u064c"+ + "\u0670\u0671\u0673\u06d5\u06d7\u06fe\u0701\u0712\u0714\u0731\u074f\u07a7"+ + "\u07b3\u07ec\u0802\u0817\u0842\u085a\u08a2\u08b4\u0906\u093b\u093f\u0952"+ + "\u095a\u0963\u0974\u0982\u0987\u098e\u0991\u0992\u0995\u09aa\u09ac\u09b2"+ + "\u09b4\u09bb\u09bf\u09d0\u09de\u09df\u09e1\u09e3\u09f2\u09f3\u0a07\u0a0c"+ + "\u0a11\u0a12\u0a15\u0a2a\u0a2c\u0a32\u0a34\u0a35\u0a37\u0a38\u0a3a\u0a3b"+ + "\u0a5b\u0a5e\u0a60\u0a76\u0a87\u0a8f\u0a91\u0a93\u0a95\u0aaa\u0aac\u0ab2"+ + "\u0ab4\u0ab5\u0ab7\u0abb\u0abf\u0ad2\u0ae2\u0ae3\u0b07\u0b0e\u0b11\u0b12"+ + "\u0b15\u0b2a\u0b2c\u0b32\u0b34\u0b35\u0b37\u0b3b\u0b3f\u0b63\u0b73\u0b85"+ + "\u0b87\u0b8c\u0b90\u0b92\u0b94\u0b97\u0b9b\u0b9c\u0b9e\u0bac\u0bb0\u0bbb"+ + "\u0bd2\u0c0e\u0c10\u0c12\u0c14\u0c2a\u0c2c\u0c3b\u0c3f\u0c8e\u0c90\u0c92"+ + "\u0c94\u0caa\u0cac\u0cb5\u0cb7\u0cbb\u0cbf\u0ce0\u0ce2\u0ce3\u0cf3\u0cf4"+ + "\u0d07\u0d0e\u0d10\u0d12\u0d14\u0d3c\u0d3f\u0d50\u0d62\u0d63\u0d7c\u0d81"+ + "\u0d87\u0d98\u0d9c\u0db3\u0db5\u0dbd\u0dbf\u0dc8\u0e03\u0e32\u0e34\u0e35"+ + "\u0e42\u0e47\u0e83\u0e84\u0e86\u0e8c\u0e8f\u0e99\u0e9b\u0ea1\u0ea3\u0ea5"+ + "\u0ea7\u0ea9\u0eac\u0ead\u0eaf\u0eb2\u0eb4\u0eb5\u0ebf\u0ec6\u0ede\u0ee1"+ + "\u0f02\u0f49\u0f4b\u0f6e\u0f8a\u0f8e\u1002\u102c\u1041\u1057\u105c\u105f"+ + "\u1063\u1072\u1077\u1083\u1090\u10fc\u10ff\u124a\u124c\u124f\u1252\u1258"+ + "\u125a\u125f\u1262\u128a\u128c\u128f\u1292\u12b2\u12b4\u12b7\u12ba\u12c0"+ + "\u12c2\u12c7\u12ca\u12d8\u12da\u1312\u1314\u1317\u131a\u135c\u1382\u1391"+ + "\u13a2\u13f6\u1403\u166e\u1671\u1681\u1683\u169c\u16a2\u16ec\u16f3\u16fa"+ + "\u1702\u170e\u1710\u1713\u1722\u1733\u1742\u1753\u1762\u176e\u1770\u1772"+ + "\u1782\u17b5\u17de\u1844\u1846\u1879\u1882\u18aa\u18ac\u18f7\u1902\u1920"+ + "\u1952\u196f\u1972\u1976\u1982\u19ad\u19c3\u19c9\u1a02\u1a18\u1a22\u1a56"+ + "\u1b07\u1b35\u1b47\u1b4d\u1b85\u1ba2\u1bb0\u1bb1\u1bbc\u1be7\u1c02\u1c25"+ + "\u1c4f\u1c51\u1c5c\u1c79\u1ceb\u1cee\u1cf0\u1cf3\u1cf7\u1cf8\u2137\u213a"+ + "\u2d32\u2d69\u2d82\u2d98\u2da2\u2da8\u2daa\u2db0\u2db2\u2db8\u2dba\u2dc0"+ + "\u2dc2\u2dc8\u2dca\u2dd0\u2dd2\u2dd8\u2dda\u2de0\u3008\u303e\u3043\u3098"+ + "\u30a1\u30fc\u3101\u312f\u3133\u3190\u31a2\u31bc\u31f2\u3201\u3402\u4db7"+ + "\u4e02\u9fce\ua002\ua016\ua018\ua48e\ua4d2\ua4f9\ua502\ua60d\ua612\ua621"+ + "\ua62c\ua62d\ua670\ua6e7\ua7f9\ua803\ua805\ua807\ua809\ua80c\ua80e\ua824"+ + "\ua842\ua875\ua884\ua8b5\ua8f4\ua8f9\ua8fd\ua927\ua932\ua948\ua962\ua97e"+ + "\ua986\ua9b4\ua9e2\ua9e6\ua9e9\ua9f1\ua9fc\uaa00\uaa02\uaa2a\uaa42\uaa44"+ + "\uaa46\uaa4d\uaa62\uaa71\uaa73\uaa78\uaa7c\uaab1\uaab3\uaabf\uaac2\uaac4"+ + "\uaadd\uaade\uaae2\uaaec\uaaf4\uab08\uab0b\uab10\uab13\uab18\uab22\uab28"+ + "\uab2a\uab30\uabc2\uabe4\uac02\ud7a5\ud7b2\ud7c8\ud7cd\ud7fd\uf902\ufa6f"+ + "\ufa72\ufadb\ufb1f\ufb2a\ufb2c\ufb38\ufb3a\ufb3e\ufb40\ufbb3\ufbd5\ufd3f"+ + "\ufd52\ufd91\ufd94\ufdc9\ufdf2\ufdfd\ufe72\ufe76\ufe78\ufefe\uff68\uff71"+ + "\uff73\uff9f\uffa2\uffc0\uffc4\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde"+ + "\4\2\u16f0\u16f2\u2162\u2171\5\2\u0905\u0905\u0940\u0942\u094b\u094e\5"+ + "\2\u00af\u00af\u0602\u0605\u06df\u06df\b\2aa\u2041\u2042\u2056\u2056\ufe35"+ + "\ufe36\ufe4f\ufe51\uff41\uff41\'\2\62;\u0662\u066b\u06f2\u06fb\u07c2\u07cb"+ + "\u0968\u0971\u09e8\u09f1\u0a68\u0a71\u0ae8\u0af1\u0b68\u0b71\u0be8\u0bf1"+ + "\u0c68\u0c71\u0ce8\u0cf1\u0d68\u0d71\u0de8\u0df1\u0e52\u0e5b\u0ed2\u0edb"+ + "\u0f22\u0f2b\u1042\u104b\u1092\u109b\u17e2\u17eb\u1812\u181b\u1948\u1951"+ + "\u19d2\u19db\u1a82\u1a8b\u1a92\u1a9b\u1b52\u1b5b\u1bb2\u1bbb\u1c42\u1c4b"+ + "\u1c52\u1c5b\ua622\ua62b\ua8d2\ua8db\ua902\ua90b\ua9d2\ua9db\ua9f2\ua9fb"+ + "\uaa52\uaa5b\uabf2\uabfb\uff12\uff1b\2\u084e\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\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\177\3\2\2\2\2\u0081\3\2\2"+ + "\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b"+ + "\3\2\2\2\2\u008d\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2"+ + "\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b\3\2\2\2\2\u009d"+ + "\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2"+ + "\2\2\u00a7\3\2\2\2\2\u00a9\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af"+ + "\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2"+ + "\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1"+ + "\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5\3\2\2\2\2\u00c7\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\u0127\3\2\2\2\2\u0129\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\2\u0135\3\2\2"+ + "\2\2\u0137\3\2\2\2\2\u0139\3\2\2\2\2\u013b\3\2\2\2\2\u013d\3\2\2\2\2\u013f"+ + "\3\2\2\2\2\u0141\3\2\2\2\2\u0143\3\2\2\2\2\u0145\3\2\2\2\2\u0147\3\2\2"+ + "\2\2\u0149\3\2\2\2\2\u014b\3\2\2\2\2\u014d\3\2\2\2\2\u014f\3\2\2\2\2\u0151"+ + "\3\2\2\2\2\u0153\3\2\2\2\2\u0155\3\2\2\2\2\u0157\3\2\2\2\2\u0159\3\2\2"+ + "\2\2\u015b\3\2\2\2\3\u015d\3\2\2\2\3\u015f\3\2\2\2\3\u0161\3\2\2\2\3\u0163"+ + "\3\2\2\2\3\u0165\3\2\2\2\3\u0167\3\2\2\2\3\u0169\3\2\2\2\4\u016b\3\2\2"+ + "\2\4\u016d\3\2\2\2\4\u016f\3\2\2\2\5\u0171\3\2\2\2\5\u0173\3\2\2\2\5\u0175"+ + "\3\2\2\2\5\u0177\3\2\2\2\5\u0179\3\2\2\2\5\u017b\3\2\2\2\5\u017d\3\2\2"+ + "\2\5\u017f\3\2\2\2\5\u0181\3\2\2\2\5\u0183\3\2\2\2\5\u0185\3\2\2\2\5\u0187"+ + "\3\2\2\2\5\u0189\3\2\2\2\5\u018b\3\2\2\2\5\u018d\3\2\2\2\5\u018f\3\2\2"+ + "\2\5\u0191\3\2\2\2\5\u0193\3\2\2\2\5\u0195\3\2\2\2\5\u0197\3\2\2\2\5\u0199"+ + "\3\2\2\2\5\u019b\3\2\2\2\5\u019d\3\2\2\2\5\u019f\3\2\2\2\5\u01a1\3\2\2"+ + "\2\5\u01a3\3\2\2\2\5\u01a5\3\2\2\2\5\u01a7\3\2\2\2\5\u01a9\3\2\2\2\5\u01ab"+ + "\3\2\2\2\6\u01ad\3\2\2\2\6\u01af\3\2\2\2\7\u01ef\3\2\2\2\t\u01f3\3\2\2"+ + "\2\13\u01ff\3\2\2\2\r\u0207\3\2\2\2\17\u0217\3\2\2\2\21\u0222\3\2\2\2"+ + "\23\u0232\3\2\2\2\25\u0238\3\2\2\2\27\u023c\3\2\2\2\31\u0245\3\2\2\2\33"+ + "\u0249\3\2\2\2\35\u024f\3\2\2\2\37\u0259\3\2\2\2!\u025c\3\2\2\2#\u0266"+ + "\3\2\2\2%\u026c\3\2\2\2\'\u0272\3\2\2\2)\u0277\3\2\2\2+\u027c\3\2\2\2"+ + "-\u0282\3\2\2\2/\u0285\3\2\2\2\61\u028a\3\2\2\2\63\u028f\3\2\2\2\65\u0295"+ + "\3\2\2\2\67\u029a\3\2\2\29\u02a2\3\2\2\2;\u02a8\3\2\2\2=\u02ae\3\2\2\2"+ + "?\u02b7\3\2\2\2A\u02bf\3\2\2\2C\u02c7\3\2\2\2E\u02d0\3\2\2\2G\u02db\3"+ + "\2\2\2I\u02de\3\2\2\2K\u02e5\3\2\2\2M\u02ed\3\2\2\2O\u02f2\3\2\2\2Q\u02f7"+ + "\3\2\2\2S\u02fe\3\2\2\2U\u0304\3\2\2\2W\u030d\3\2\2\2Y\u0314\3\2\2\2["+ + "\u031a\3\2\2\2]\u0322\3\2\2\2_\u0328\3\2\2\2a\u032e\3\2\2\2c\u0332\3\2"+ + "\2\2e\u033a\3\2\2\2g\u033f\3\2\2\2i\u0343\3\2\2\2k\u0348\3\2\2\2m\u034e"+ + "\3\2\2\2o\u0351\3\2\2\2q\u035a\3\2\2\2s\u035d\3\2\2\2u\u0361\3\2\2\2w"+ + "\u036b\3\2\2\2y\u0374\3\2\2\2{\u0379\3\2\2\2}\u037c\3\2\2\2\177\u0381"+ + "\3\2\2\2\u0081\u0385\3\2\2\2\u0083\u038a\3\2\2\2\u0085\u038f\3\2\2\2\u0087"+ + "\u0396\3\2\2\2\u0089\u03a0\3\2\2\2\u008b\u03a4\3\2\2\2\u008d\u03a9\3\2"+ + "\2\2\u008f\u03b0\3\2\2\2\u0091\u03b3\3\2\2\2\u0093\u03bc\3\2\2\2\u0095"+ + "\u03c4\3\2\2\2\u0097\u03c8\3\2\2\2\u0099\u03d1\3\2\2\2\u009b\u03d8\3\2"+ + "\2\2\u009d\u03e0\3\2\2\2\u009f\u03e8\3\2\2\2\u00a1\u03f2\3\2\2\2\u00a3"+ + "\u03f9\3\2\2\2\u00a5\u0402\3\2\2\2\u00a7\u0406\3\2\2\2\u00a9\u040d\3\2"+ + "\2\2\u00ab\u0414\3\2\2\2\u00ad\u041a\3\2\2\2\u00af\u0421\3\2\2\2\u00b1"+ + "\u0428\3\2\2\2\u00b3\u042c\3\2\2\2\u00b5\u0432\3\2\2\2\u00b7\u0439\3\2"+ + "\2\2\u00b9\u0444\3\2\2\2\u00bb\u044b\3\2\2\2\u00bd\u0452\3\2\2\2\u00bf"+ + "\u0459\3\2\2\2\u00c1\u0460\3\2\2\2\u00c3\u0465\3\2\2\2\u00c5\u046b\3\2"+ + "\2\2\u00c7\u0470\3\2\2\2\u00c9\u0474\3\2\2\2\u00cb\u047b\3\2\2\2\u00cd"+ + "\u0480\3\2\2\2\u00cf\u0486\3\2\2\2\u00d1\u0490\3\2\2\2\u00d3\u049a\3\2"+ + "\2\2\u00d5\u04a1\3\2\2\2\u00d7\u04a8\3\2\2\2\u00d9\u04ae\3\2\2\2\u00db"+ + "\u04b2\3\2\2\2\u00dd\u04ba\3\2\2\2\u00df\u04bf\3\2\2\2\u00e1\u04c8\3\2"+ + "\2\2\u00e3\u04cd\3\2\2\2\u00e5\u04d3\3\2\2\2\u00e7\u04d9\3\2\2\2\u00e9"+ + "\u04e0\3\2\2\2\u00eb\u04e4\3\2\2\2\u00ed\u04fa\3\2\2\2\u00ef\u050a\3\2"+ + "\2\2\u00f1\u051a\3\2\2\2\u00f3\u0561\3\2\2\2\u00f5\u0563\3\2\2\2\u00f7"+ + "\u056a\3\2\2\2\u00f9\u0574\3\2\2\2\u00fb\u0581\3\2\2\2\u00fd\u0588\3\2"+ + "\2\2\u00ff\u0590\3\2\2\2\u0101\u0593\3\2\2\2\u0103\u0596\3\2\2\2\u0105"+ + "\u0598\3\2\2\2\u0107\u059a\3\2\2\2\u0109\u059c\3\2\2\2\u010b\u059e\3\2"+ + "\2\2\u010d\u05a0\3\2\2\2\u010f\u05a2\3\2\2\2\u0111\u05a5\3\2\2\2\u0113"+ + "\u05a7\3\2\2\2\u0115\u05a9\3\2\2\2\u0117\u05ab\3\2\2\2\u0119\u05ad\3\2"+ + "\2\2\u011b\u05af\3\2\2\2\u011d\u05b1\3\2\2\2\u011f\u05b3\3\2\2\2\u0121"+ + "\u05b5\3\2\2\2\u0123\u05b7\3\2\2\2\u0125\u05b9\3\2\2\2\u0127\u05bb\3\2"+ + "\2\2\u0129\u05bd\3\2\2\2\u012b\u05bf\3\2\2\2\u012d\u05c1\3\2\2\2\u012f"+ + "\u05c3\3\2\2\2\u0131\u05c6\3\2\2\2\u0133\u05c9\3\2\2\2\u0135\u05cc\3\2"+ + "\2\2\u0137\u05cf\3\2\2\2\u0139\u05d2\3\2\2\2\u013b\u05d5\3\2\2\2\u013d"+ + "\u05d8\3\2\2\2\u013f\u05db\3\2\2\2\u0141\u05de\3\2\2\2\u0143\u05e1\3\2"+ + "\2\2\u0145\u05e4\3\2\2\2\u0147\u05e7\3\2\2\2\u0149\u05ea\3\2\2\2\u014b"+ + "\u05ed\3\2\2\2\u014d\u05f0\3\2\2\2\u014f\u05f3\3\2\2\2\u0151\u05f6\3\2"+ + "\2\2\u0153\u05f9\3\2\2\2\u0155\u05fc\3\2\2\2\u0157\u05ff\3\2\2\2\u0159"+ + "\u0603\3\2\2\2\u015b\u0607\3\2\2\2\u015d\u060a\3\2\2\2\u015f\u060d\3\2"+ + "\2\2\u0161\u0613\3\2\2\2\u0163\u0616\3\2\2\2\u0165\u061a\3\2\2\2\u0167"+ + "\u061f\3\2\2\2\u0169\u0625\3\2\2\2\u016b\u062b\3\2\2\2\u016d\u0630\3\2"+ + "\2\2\u016f\u0637\3\2\2\2\u0171\u063c\3\2\2\2\u0173\u0643\3\2\2\2\u0175"+ + "\u0649\3\2\2\2\u0177\u0651\3\2\2\2\u0179\u065a\3\2\2\2\u017b\u0663\3\2"+ + "\2\2\u017d\u066b\3\2\2\2\u017f\u0671\3\2\2\2\u0181\u0678\3\2\2\2\u0183"+ + "\u0680\3\2\2\2\u0185\u0688\3\2\2\2\u0187\u068f\3\2\2\2\u0189\u069d\3\2"+ + "\2\2\u018b\u06ad\3\2\2\2\u018d\u06bd\3\2\2\2\u018f\u06d0\3\2\2\2\u0191"+ + "\u06df\3\2\2\2\u0193\u06f0\3\2\2\2\u0195\u06fb\3\2\2\2\u0197\u0704\3\2"+ + "\2\2\u0199\u0709\3\2\2\2\u019b\u070e\3\2\2\2\u019d\u0713\3\2\2\2\u019f"+ + "\u0719\3\2\2\2\u01a1\u071f\3\2\2\2\u01a3\u0725\3\2\2\2\u01a5\u072b\3\2"+ + "\2\2\u01a7\u0737\3\2\2\2\u01a9\u073b\3\2\2\2\u01ab\u0747\3\2\2\2\u01ad"+ + "\u074d\3\2\2\2\u01af\u0753\3\2\2\2\u01b1\u0759\3\2\2\2\u01b3\u075b\3\2"+ + "\2\2\u01b5\u0765\3\2\2\2\u01b7\u0767\3\2\2\2\u01b9\u077b\3\2\2\2\u01bb"+ + "\u0793\3\2\2\2\u01bd\u07ae\3\2\2\2\u01bf\u07b3\3\2\2\2\u01c1\u07b7\3\2"+ + "\2\2\u01c3\u07b9\3\2\2\2\u01c5\u07bb\3\2\2\2\u01c7\u07c4\3\2\2\2\u01c9"+ + "\u07cb\3\2\2\2\u01cb\u07d4\3\2\2\2\u01cd\u07d8\3\2\2\2\u01cf\u07dc\3\2"+ + "\2\2\u01d1\u07e1\3\2\2\2\u01d3\u07e5\3\2\2\2\u01d5\u07fb\3\2\2\2\u01d7"+ + "\u07fe\3\2\2\2\u01d9\u0800\3\2\2\2\u01db\u0802\3\2\2\2\u01dd\u0804\3\2"+ + "\2\2\u01df\u0806\3\2\2\2\u01e1\u0808\3\2\2\2\u01e3\u080a\3\2\2\2\u01e5"+ + "\u080c\3\2\2\2\u01e7\u080e\3\2\2\2\u01e9\u0810\3\2\2\2\u01eb\u0812\3\2"+ + "\2\2\u01ed\u0814\3\2\2\2\u01ef\u01f0\7\u00f1\2\2\u01f0\u01f1\7\u00bd\2"+ + "\2\u01f1\u01f2\7\u00c1\2\2\u01f2\b\3\2\2\2\u01f3\u01f4\7\61\2\2\u01f4"+ + "\u01f5\7\61\2\2\u01f5\u01f6\7\61\2\2\u01f6\u01fa\3\2\2\2\u01f7\u01f9\5"+ + "\u01b1\u00d7\2\u01f8\u01f7\3\2\2\2\u01f9\u01fc\3\2\2\2\u01fa\u01f8\3\2"+ + "\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fd\3\2\2\2\u01fc\u01fa\3\2\2\2\u01fd"+ + "\u01fe\b\3\2\2\u01fe\n\3\2\2\2\u01ff\u0200\7\61\2\2\u0200\u0201\7,\2\2"+ + "\u0201\u0202\7,\2\2\u0202\u0203\7,\2\2\u0203\u0204\7\61\2\2\u0204\u0205"+ + "\3\2\2\2\u0205\u0206\b\4\2\2\u0206\f\3\2\2\2\u0207\u0208\7\61\2\2\u0208"+ + "\u0209\7,\2\2\u0209\u020a\7,\2\2\u020a\u020b\3\2\2\2\u020b\u020f\n\2\2"+ + "\2\u020c\u020e\13\2\2\2\u020d\u020c\3\2\2\2\u020e\u0211\3\2\2\2\u020f"+ + "\u0210\3\2\2\2\u020f\u020d\3\2\2\2\u0210\u0212\3\2\2\2\u0211\u020f\3\2"+ + "\2\2\u0212\u0213\7,\2\2\u0213\u0214\7\61\2\2\u0214\u0215\3\2\2\2\u0215"+ + "\u0216\b\5\2\2\u0216\16\3\2\2\2\u0217\u0218\7\61\2\2\u0218\u0219\7\61"+ + "\2\2\u0219\u021d\3\2\2\2\u021a\u021c\5\u01b1\u00d7\2\u021b\u021a\3\2\2"+ + "\2\u021c\u021f\3\2\2\2\u021d\u021b\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u0220"+ + "\3\2\2\2\u021f\u021d\3\2\2\2\u0220\u0221\b\6\2\2\u0221\20\3\2\2\2\u0222"+ + "\u0223\7\61\2\2\u0223\u0224\7,\2\2\u0224\u0228\3\2\2\2\u0225\u0227\13"+ + "\2\2\2\u0226\u0225\3\2\2\2\u0227\u022a\3\2\2\2\u0228\u0229\3\2\2\2\u0228"+ + "\u0226\3\2\2\2\u0229\u022b\3\2\2\2\u022a\u0228\3\2\2\2\u022b\u022c\7,"+ + "\2\2\u022c\u022d\7\61\2\2\u022d\u022e\3\2\2\2\u022e\u022f\b\7\2\2\u022f"+ + "\22\3\2\2\2\u0230\u0233\5\u01c1\u00df\2\u0231\u0233\5\u01bf\u00de\2\u0232"+ + "\u0230\3\2\2\2\u0232\u0231\3\2\2\2\u0233\u0234\3\2\2\2\u0234\u0232\3\2"+ + "\2\2\u0234\u0235\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u0237\b\b\3\2\u0237"+ + "\24\3\2\2\2\u0238\u0239\7%\2\2\u0239\u023a\3\2\2\2\u023a\u023b\b\t\4\2"+ + "\u023b\26\3\2\2\2\u023c\u023d\7c\2\2\u023d\u023e\7d\2\2\u023e\u023f\7"+ + "u\2\2\u023f\u0240\7v\2\2\u0240\u0241\7t\2\2\u0241\u0242\7c\2\2\u0242\u0243"+ + "\7e\2\2\u0243\u0244\7v\2\2\u0244\30\3\2\2\2\u0245\u0246\7c\2\2\u0246\u0247"+ + "\7f\2\2\u0247\u0248\7f\2\2\u0248\32\3\2\2\2\u0249\u024a\7c\2\2\u024a\u024b"+ + "\7n\2\2\u024b\u024c\7k\2\2\u024c\u024d\7c\2\2\u024d\u024e\7u\2\2\u024e"+ + "\34\3\2\2\2\u024f\u0250\7a\2\2\u0250\u0251\7a\2\2\u0251\u0252\7c\2\2\u0252"+ + "\u0253\7t\2\2\u0253\u0254\7i\2\2\u0254\u0255\7n\2\2\u0255\u0256\7k\2\2"+ + "\u0256\u0257\7u\2\2\u0257\u0258\7v\2\2\u0258\36\3\2\2\2\u0259\u025a\7"+ + "c\2\2\u025a\u025b\7u\2\2\u025b \3\2\2\2\u025c\u025d\7c\2\2\u025d\u025e"+ + "\7u\2\2\u025e\u025f\7e\2\2\u025f\u0260\7g\2\2\u0260\u0261\7p\2\2\u0261"+ + "\u0262\7f\2\2\u0262\u0263\7k\2\2\u0263\u0264\7p\2\2\u0264\u0265\7i\2\2"+ + "\u0265\"\3\2\2\2\u0266\u0267\7c\2\2\u0267\u0268\7u\2\2\u0268\u0269\7{"+ + "\2\2\u0269\u026a\7p\2\2\u026a\u026b\7e\2\2\u026b$\3\2\2\2\u026c\u026d"+ + "\7c\2\2\u026d\u026e\7y\2\2\u026e\u026f\7c\2\2\u026f\u0270\7k\2\2\u0270"+ + "\u0271\7v\2\2\u0271&\3\2\2\2\u0272\u0273\7d\2\2\u0273\u0274\7c\2\2\u0274"+ + "\u0275\7u\2\2\u0275\u0276\7g\2\2\u0276(\3\2\2\2\u0277\u0278\7d\2\2\u0278"+ + "\u0279\7q\2\2\u0279\u027a\7q\2\2\u027a\u027b\7n\2\2\u027b*\3\2\2\2\u027c"+ + "\u027d\7d\2\2\u027d\u027e\7t\2\2\u027e\u027f\7g\2\2\u027f\u0280\7c\2\2"+ + "\u0280\u0281\7m\2\2\u0281,\3\2\2\2\u0282\u0283\7d\2\2\u0283\u0284\7{\2"+ + "\2\u0284.\3\2\2\2\u0285\u0286\7d\2\2\u0286\u0287\7{\2\2\u0287\u0288\7"+ + "v\2\2\u0288\u0289\7g\2\2\u0289\60\3\2\2\2\u028a\u028b\7e\2\2\u028b\u028c"+ + "\7c\2\2\u028c\u028d\7u\2\2\u028d\u028e\7g\2\2\u028e\62\3\2\2\2\u028f\u0290"+ + "\7e\2\2\u0290\u0291\7c\2\2\u0291\u0292\7v\2\2\u0292\u0293\7e\2\2\u0293"+ + "\u0294\7j\2\2\u0294\64\3\2\2\2\u0295\u0296\7e\2\2\u0296\u0297\7j\2\2\u0297"+ + "\u0298\7c\2\2\u0298\u0299\7t\2\2\u0299\66\3\2\2\2\u029a\u029b\7e\2\2\u029b"+ + "\u029c\7j\2\2\u029c\u029d\7g\2\2\u029d\u029e\7e\2\2\u029e\u029f\7m\2\2"+ + "\u029f\u02a0\7g\2\2\u02a0\u02a1\7f\2\2\u02a18\3\2\2\2\u02a2\u02a3\7e\2"+ + "\2\u02a3\u02a4\7n\2\2\u02a4\u02a5\7c\2\2\u02a5\u02a6\7u\2\2\u02a6\u02a7"+ + "\7u\2\2\u02a7:\3\2\2\2\u02a8\u02a9\7e\2\2\u02a9\u02aa\7q\2\2\u02aa\u02ab"+ + "\7p\2\2\u02ab\u02ac\7u\2\2\u02ac\u02ad\7v\2\2\u02ad<\3\2\2\2\u02ae\u02af"+ + "\7e\2\2\u02af\u02b0\7q\2\2\u02b0\u02b1\7p\2\2\u02b1\u02b2\7v\2\2\u02b2"+ + "\u02b3\7k\2\2\u02b3\u02b4\7p\2\2\u02b4\u02b5\7w\2\2\u02b5\u02b6\7g\2\2"+ + "\u02b6>\3\2\2\2\u02b7\u02b8\7f\2\2\u02b8\u02b9\7g\2\2\u02b9\u02ba\7e\2"+ + "\2\u02ba\u02bb\7k\2\2\u02bb\u02bc\7o\2\2\u02bc\u02bd\7c\2\2\u02bd\u02be"+ + "\7n\2\2\u02be@\3\2\2\2\u02bf\u02c0\7f\2\2\u02c0\u02c1\7g\2\2\u02c1\u02c2"+ + "\7h\2\2\u02c2\u02c3\7c\2\2\u02c3\u02c4\7w\2\2\u02c4\u02c5\7n\2\2\u02c5"+ + "\u02c6\7v\2\2\u02c6B\3\2\2\2\u02c7\u02c8\7f\2\2\u02c8\u02c9\7g\2\2\u02c9"+ + "\u02ca\7n\2\2\u02ca\u02cb\7g\2\2\u02cb\u02cc\7i\2\2\u02cc\u02cd\7c\2\2"+ + "\u02cd\u02ce\7v\2\2\u02ce\u02cf\7g\2\2\u02cfD\3\2\2\2\u02d0\u02d1\7f\2"+ + "\2\u02d1\u02d2\7g\2\2\u02d2\u02d3\7u\2\2\u02d3\u02d4\7e\2\2\u02d4\u02d5"+ + "\7g\2\2\u02d5\u02d6\7p\2\2\u02d6\u02d7\7f\2\2\u02d7\u02d8\7k\2\2\u02d8"+ + "\u02d9\7p\2\2\u02d9\u02da\7i\2\2\u02daF\3\2\2\2\u02db\u02dc\7f\2\2\u02dc"+ + "\u02dd\7q\2\2\u02ddH\3\2\2\2\u02de\u02df\7f\2\2\u02df\u02e0\7q\2\2\u02e0"+ + "\u02e1\7w\2\2\u02e1\u02e2\7d\2\2\u02e2\u02e3\7n\2\2\u02e3\u02e4\7g\2\2"+ + "\u02e4J\3\2\2\2\u02e5\u02e6\7f\2\2\u02e6\u02e7\7{\2\2\u02e7\u02e8\7p\2"+ + "\2\u02e8\u02e9\7c\2\2\u02e9\u02ea\7o\2\2\u02ea\u02eb\7k\2\2\u02eb\u02ec"+ + "\7e\2\2\u02ecL\3\2\2\2\u02ed\u02ee\7g\2\2\u02ee\u02ef\7n\2\2\u02ef\u02f0"+ + "\7u\2\2\u02f0\u02f1\7g\2\2\u02f1N\3\2\2\2\u02f2\u02f3\7g\2\2\u02f3\u02f4"+ + "\7p\2\2\u02f4\u02f5\7w\2\2\u02f5\u02f6\7o\2\2\u02f6P\3\2\2\2\u02f7\u02f8"+ + "\7g\2\2\u02f8\u02f9\7s\2\2\u02f9\u02fa\7w\2\2\u02fa\u02fb\7c\2\2\u02fb"+ + "\u02fc\7n\2\2\u02fc\u02fd\7u\2\2\u02fdR\3\2\2\2\u02fe\u02ff\7g\2\2\u02ff"+ + "\u0300\7x\2\2\u0300\u0301\7g\2\2\u0301\u0302\7p\2\2\u0302\u0303\7v\2\2"+ + "\u0303T\3\2\2\2\u0304\u0305\7g\2\2\u0305\u0306\7z\2\2\u0306\u0307\7r\2"+ + "\2\u0307\u0308\7n\2\2\u0308\u0309\7k\2\2\u0309\u030a\7e\2\2\u030a\u030b"+ + "\7k\2\2\u030b\u030c\7v\2\2\u030cV\3\2\2\2\u030d\u030e\7g\2\2\u030e\u030f"+ + "\7z\2\2\u030f\u0310\7v\2\2\u0310\u0311\7g\2\2\u0311\u0312\7t\2\2\u0312"+ + "\u0313\7p\2\2\u0313X\3\2\2\2\u0314\u0315\7h\2\2\u0315\u0316\7c\2\2\u0316"+ + "\u0317\7n\2\2\u0317\u0318\7u\2\2\u0318\u0319\7g\2\2\u0319Z\3\2\2\2\u031a"+ + "\u031b\7h\2\2\u031b\u031c\7k\2\2\u031c\u031d\7p\2\2\u031d\u031e\7c\2\2"+ + "\u031e\u031f\7n\2\2\u031f\u0320\7n\2\2\u0320\u0321\7{\2\2\u0321\\\3\2"+ + "\2\2\u0322\u0323\7h\2\2\u0323\u0324\7k\2\2\u0324\u0325\7z\2\2\u0325\u0326"+ + "\7g\2\2\u0326\u0327\7f\2\2\u0327^\3\2\2\2\u0328\u0329\7h\2\2\u0329\u032a"+ + "\7n\2\2\u032a\u032b\7q\2\2\u032b\u032c\7c\2\2\u032c\u032d\7v\2\2\u032d"+ + "`\3\2\2\2\u032e\u032f\7h\2\2\u032f\u0330\7q\2\2\u0330\u0331\7t\2\2\u0331"+ + "b\3\2\2\2\u0332\u0333\7h\2\2\u0333\u0334\7q\2\2\u0334\u0335\7t\2\2\u0335"+ + "\u0336\7g\2\2\u0336\u0337\7c\2\2\u0337\u0338\7e\2\2\u0338\u0339\7j\2\2"+ + "\u0339d\3\2\2\2\u033a\u033b\7h\2\2\u033b\u033c\7t\2\2\u033c\u033d\7q\2"+ + "\2\u033d\u033e\7o\2\2\u033ef\3\2\2\2\u033f\u0340\7i\2\2\u0340\u0341\7"+ + "g\2\2\u0341\u0342\7v\2\2\u0342h\3\2\2\2\u0343\u0344\7i\2\2\u0344\u0345"+ + "\7q\2\2\u0345\u0346\7v\2\2\u0346\u0347\7q\2\2\u0347j\3\2\2\2\u0348\u0349"+ + "\7i\2\2\u0349\u034a\7t\2\2\u034a\u034b\7q\2\2\u034b\u034c\7w\2\2\u034c"+ + "\u034d\7r\2\2\u034dl\3\2\2\2\u034e\u034f\7k\2\2\u034f\u0350\7h\2\2\u0350"+ + "n\3\2\2\2\u0351\u0352\7k\2\2\u0352\u0353\7o\2\2\u0353\u0354\7r\2\2\u0354"+ + "\u0355\7n\2\2\u0355\u0356\7k\2\2\u0356\u0357\7e\2\2\u0357\u0358\7k\2\2"+ + "\u0358\u0359\7v\2\2\u0359p\3\2\2\2\u035a\u035b\7k\2\2\u035b\u035c\7p\2"+ + "\2\u035cr\3\2\2\2\u035d\u035e\7k\2\2\u035e\u035f\7p\2\2\u035f\u0360\7"+ + "v\2\2\u0360t\3\2\2\2\u0361\u0362\7k\2\2\u0362\u0363\7p\2\2\u0363\u0364"+ + "\7v\2\2\u0364\u0365\7g\2\2\u0365\u0366\7t\2\2\u0366\u0367\7h\2\2\u0367"+ + "\u0368\7c\2\2\u0368\u0369\7e\2\2\u0369\u036a\7g\2\2\u036av\3\2\2\2\u036b"+ + "\u036c\7k\2\2\u036c\u036d\7p\2\2\u036d\u036e\7v\2\2\u036e\u036f\7g\2\2"+ + "\u036f\u0370\7t\2\2\u0370\u0371\7p\2\2\u0371\u0372\7c\2\2\u0372\u0373"+ + "\7n\2\2\u0373x\3\2\2\2\u0374\u0375\7k\2\2\u0375\u0376\7p\2\2\u0376\u0377"+ + "\7v\2\2\u0377\u0378\7q\2\2\u0378z\3\2\2\2\u0379\u037a\7k\2\2\u037a\u037b"+ + "\7u\2\2\u037b|\3\2\2\2\u037c\u037d\7l\2\2\u037d\u037e\7q\2\2\u037e\u037f"+ + "\7k\2\2\u037f\u0380\7p\2\2\u0380~\3\2\2\2\u0381\u0382\7n\2\2\u0382\u0383"+ + "\7g\2\2\u0383\u0384\7v\2\2\u0384\u0080\3\2\2\2\u0385\u0386\7n\2\2\u0386"+ + "\u0387\7q\2\2\u0387\u0388\7e\2\2\u0388\u0389\7m\2\2\u0389\u0082\3\2\2"+ + "\2\u038a\u038b\7n\2\2\u038b\u038c\7q\2\2\u038c\u038d\7p\2\2\u038d\u038e"+ + "\7i\2\2\u038e\u0084\3\2\2\2\u038f\u0390\7p\2\2\u0390\u0391\7c\2\2\u0391"+ + "\u0392\7o\2\2\u0392\u0393\7g\2\2\u0393\u0394\7q\2\2\u0394\u0395\7h\2\2"+ + "\u0395\u0086\3\2\2\2\u0396\u0397\7p\2\2\u0397\u0398\7c\2\2\u0398\u0399"+ + "\7o\2\2\u0399\u039a\7g\2\2\u039a\u039b\7u\2\2\u039b\u039c\7r\2\2\u039c"+ + "\u039d\7c\2\2\u039d\u039e\7e\2\2\u039e\u039f\7g\2\2\u039f\u0088\3\2\2"+ + "\2\u03a0\u03a1\7p\2\2\u03a1\u03a2\7g\2\2\u03a2\u03a3\7y\2\2\u03a3\u008a"+ + "\3\2\2\2\u03a4\u03a5\7p\2\2\u03a5\u03a6\7w\2\2\u03a6\u03a7\7n\2\2\u03a7"+ + "\u03a8\7n\2\2\u03a8\u008c\3\2\2\2\u03a9\u03aa\7q\2\2\u03aa\u03ab\7d\2"+ + "\2\u03ab\u03ac\7l\2\2\u03ac\u03ad\7g\2\2\u03ad\u03ae\7e\2\2\u03ae\u03af"+ + "\7v\2\2\u03af\u008e\3\2\2\2\u03b0\u03b1\7q\2\2\u03b1\u03b2\7p\2\2\u03b2"+ + "\u0090\3\2\2\2\u03b3\u03b4\7q\2\2\u03b4\u03b5\7r\2\2\u03b5\u03b6\7g\2"+ + "\2\u03b6\u03b7\7t\2\2\u03b7\u03b8\7c\2\2\u03b8\u03b9\7v\2\2\u03b9\u03ba"+ + "\7q\2\2\u03ba\u03bb\7t\2\2\u03bb\u0092\3\2\2\2\u03bc\u03bd\7q\2\2\u03bd"+ + "\u03be\7t\2\2\u03be\u03bf\7f\2\2\u03bf\u03c0\7g\2\2\u03c0\u03c1\7t\2\2"+ + "\u03c1\u03c2\7d\2\2\u03c2\u03c3\7{\2\2\u03c3\u0094\3\2\2\2\u03c4\u03c5"+ + "\7q\2\2\u03c5\u03c6\7w\2\2\u03c6\u03c7\7v\2\2\u03c7\u0096\3\2\2\2\u03c8"+ + "\u03c9\7q\2\2\u03c9\u03ca\7x\2\2\u03ca\u03cb\7g\2\2\u03cb\u03cc\7t\2\2"+ + "\u03cc\u03cd\7t\2\2\u03cd\u03ce\7k\2\2\u03ce\u03cf\7f\2\2\u03cf\u03d0"+ + "\7g\2\2\u03d0\u0098\3\2\2\2\u03d1\u03d2\7r\2\2\u03d2\u03d3\7c\2\2\u03d3"+ + "\u03d4\7t\2\2\u03d4\u03d5\7c\2\2\u03d5\u03d6\7o\2\2\u03d6\u03d7\7u\2\2"+ + "\u03d7\u009a\3\2\2\2\u03d8\u03d9\7r\2\2\u03d9\u03da\7c\2\2\u03da\u03db"+ + "\7t\2\2\u03db\u03dc\7v\2\2\u03dc\u03dd\7k\2\2\u03dd\u03de\7c\2\2\u03de"+ + "\u03df\7n\2\2\u03df\u009c\3\2\2\2\u03e0\u03e1\7r\2\2\u03e1\u03e2\7t\2"+ + "\2\u03e2\u03e3\7k\2\2\u03e3\u03e4\7x\2\2\u03e4\u03e5\7c\2\2\u03e5\u03e6"+ + "\7v\2\2\u03e6\u03e7\7g\2\2\u03e7\u009e\3\2\2\2\u03e8\u03e9\7r\2\2\u03e9"+ + "\u03ea\7t\2\2\u03ea\u03eb\7q\2\2\u03eb\u03ec\7v\2\2\u03ec\u03ed\7g\2\2"+ + "\u03ed\u03ee\7e\2\2\u03ee\u03ef\7v\2\2\u03ef\u03f0\7g\2\2\u03f0\u03f1"+ + "\7f\2\2\u03f1\u00a0\3\2\2\2\u03f2\u03f3\7r\2\2\u03f3\u03f4\7w\2\2\u03f4"+ + "\u03f5\7d\2\2\u03f5\u03f6\7n\2\2\u03f6\u03f7\7k\2\2\u03f7\u03f8\7e\2\2"+ + "\u03f8\u00a2\3\2\2\2\u03f9\u03fa\7t\2\2\u03fa\u03fb\7g\2\2\u03fb\u03fc"+ + "\7c\2\2\u03fc\u03fd\7f\2\2\u03fd\u03fe\7q\2\2\u03fe\u03ff\7p\2\2\u03ff"+ + "\u0400\7n\2\2\u0400\u0401\7{\2\2\u0401\u00a4\3\2\2\2\u0402\u0403\7t\2"+ + "\2\u0403\u0404\7g\2\2\u0404\u0405\7h\2\2\u0405\u00a6\3\2\2\2\u0406\u0407"+ + "\7t\2\2\u0407\u0408\7g\2\2\u0408\u0409\7o\2\2\u0409\u040a\7q\2\2\u040a"+ + "\u040b\7x\2\2\u040b\u040c\7g\2\2\u040c\u00a8\3\2\2\2\u040d\u040e\7t\2"+ + "\2\u040e\u040f\7g\2\2\u040f\u0410\7v\2\2\u0410\u0411\7w\2\2\u0411\u0412"+ + "\7t\2\2\u0412\u0413\7p\2\2\u0413\u00aa\3\2\2\2\u0414\u0415\7u\2\2\u0415"+ + "\u0416\7d\2\2\u0416\u0417\7{\2\2\u0417\u0418\7v\2\2\u0418\u0419\7g\2\2"+ + "\u0419\u00ac\3\2\2\2\u041a\u041b\7u\2\2\u041b\u041c\7g\2\2\u041c\u041d"+ + "\7c\2\2\u041d\u041e\7n\2\2\u041e\u041f\7g\2\2\u041f\u0420\7f\2\2\u0420"+ + "\u00ae\3\2\2\2\u0421\u0422\7u\2\2\u0422\u0423\7g\2\2\u0423\u0424\7n\2"+ + "\2\u0424\u0425\7g\2\2\u0425\u0426\7e\2\2\u0426\u0427\7v\2\2\u0427\u00b0"+ + "\3\2\2\2\u0428\u0429\7u\2\2\u0429\u042a\7g\2\2\u042a\u042b\7v\2\2\u042b"+ + "\u00b2\3\2\2\2\u042c\u042d\7u\2\2\u042d\u042e\7j\2\2\u042e\u042f\7q\2"+ + "\2\u042f\u0430\7t\2\2\u0430\u0431\7v\2\2\u0431\u00b4\3\2\2\2\u0432\u0433"+ + "\7u\2\2\u0433\u0434\7k\2\2\u0434\u0435\7|\2\2\u0435\u0436\7g\2\2\u0436"+ + "\u0437\7q\2\2\u0437\u0438\7h\2\2\u0438\u00b6\3\2\2\2\u0439\u043a\7u\2"+ + "\2\u043a\u043b\7v\2\2\u043b\u043c\7c\2\2\u043c\u043d\7e\2\2\u043d\u043e"+ + "\7m\2\2\u043e\u043f\7c\2\2\u043f\u0440\7n\2\2\u0440\u0441\7n\2\2\u0441"+ + "\u0442\7q\2\2\u0442\u0443\7e\2\2\u0443\u00b8\3\2\2\2\u0444\u0445\7u\2"+ + "\2\u0445\u0446\7v\2\2\u0446\u0447\7c\2\2\u0447\u0448\7v\2\2\u0448\u0449"+ + "\7k\2\2\u0449\u044a\7e\2\2\u044a\u00ba\3\2\2\2\u044b\u044c\7u\2\2\u044c"+ + "\u044d\7v\2\2\u044d\u044e\7t\2\2\u044e\u044f\7k\2\2\u044f\u0450\7p\2\2"+ + "\u0450\u0451\7i\2\2\u0451\u00bc\3\2\2\2\u0452\u0453\7u\2\2\u0453\u0454"+ + "\7v\2\2\u0454\u0455\7t\2\2\u0455\u0456\7w\2\2\u0456\u0457\7e\2\2\u0457"+ + "\u0458\7v\2\2\u0458\u00be\3\2\2\2\u0459\u045a\7u\2\2\u045a\u045b\7y\2"+ + "\2\u045b\u045c\7k\2\2\u045c\u045d\7v\2\2\u045d\u045e\7e\2\2\u045e\u045f"+ + "\7j\2\2\u045f\u00c0\3\2\2\2\u0460\u0461\7v\2\2\u0461\u0462\7j\2\2\u0462"+ + "\u0463\7k\2\2\u0463\u0464\7u\2\2\u0464\u00c2\3\2\2\2\u0465\u0466\7v\2"+ + "\2\u0466\u0467\7j\2\2\u0467\u0468\7t\2\2\u0468\u0469\7q\2\2\u0469\u046a"+ + "\7y\2\2\u046a\u00c4\3\2\2\2\u046b\u046c\7v\2\2\u046c\u046d\7t\2\2\u046d"+ + "\u046e\7w\2\2\u046e\u046f\7g\2\2\u046f\u00c6\3\2\2\2\u0470\u0471\7v\2"+ + "\2\u0471\u0472\7t\2\2\u0472\u0473\7{\2\2\u0473\u00c8\3\2\2\2\u0474\u0475"+ + "\7v\2\2\u0475\u0476\7{\2\2\u0476\u0477\7r\2\2\u0477\u0478\7g\2\2\u0478"+ + "\u0479\7q\2\2\u0479\u047a\7h\2\2\u047a\u00ca\3\2\2\2\u047b\u047c\7w\2"+ + "\2\u047c\u047d\7k\2\2\u047d\u047e\7p\2\2\u047e\u047f\7v\2\2\u047f\u00cc"+ + "\3\2\2\2\u0480\u0481\7w\2\2\u0481\u0482\7n\2\2\u0482\u0483\7q\2\2\u0483"+ + "\u0484\7p\2\2\u0484\u0485\7i\2\2\u0485\u00ce\3\2\2\2\u0486\u0487\7w\2"+ + "\2\u0487\u0488\7p\2\2\u0488\u0489\7e\2\2\u0489\u048a\7j\2\2\u048a\u048b"+ + "\7g\2\2\u048b\u048c\7e\2\2\u048c\u048d\7m\2\2\u048d\u048e\7g\2\2\u048e"+ + "\u048f\7f\2\2\u048f\u00d0\3\2\2\2\u0490\u0491\7w\2\2\u0491\u0492\7p\2"+ + "\2\u0492\u0493\7o\2\2\u0493\u0494\7c\2\2\u0494\u0495\7p\2\2\u0495\u0496"+ + "\7c\2\2\u0496\u0497\7i\2\2\u0497\u0498\7g\2\2\u0498\u0499\7f\2\2\u0499"+ + "\u00d2\3\2\2\2\u049a\u049b\7w\2\2\u049b\u049c\7p\2\2\u049c\u049d\7u\2"+ + "\2\u049d\u049e\7c\2\2\u049e\u049f\7h\2\2\u049f\u04a0\7g\2\2\u04a0\u00d4"+ + "\3\2\2\2\u04a1\u04a2\7w\2\2\u04a2\u04a3\7u\2\2\u04a3\u04a4\7j\2\2\u04a4"+ + "\u04a5\7q\2\2\u04a5\u04a6\7t\2\2\u04a6\u04a7\7v\2\2\u04a7\u00d6\3\2\2"+ + "\2\u04a8\u04a9\7w\2\2\u04a9\u04aa\7u\2\2\u04aa\u04ab\7k\2\2\u04ab\u04ac"+ + "\7p\2\2\u04ac\u04ad\7i\2\2\u04ad\u00d8\3\2\2\2\u04ae\u04af\7x\2\2\u04af"+ + "\u04b0\7c\2\2\u04b0\u04b1\7t\2\2\u04b1\u00da\3\2\2\2\u04b2\u04b3\7x\2"+ + "\2\u04b3\u04b4\7k\2\2\u04b4\u04b5\7t\2\2\u04b5\u04b6\7v\2\2\u04b6\u04b7"+ + "\7w\2\2\u04b7\u04b8\7c\2\2\u04b8\u04b9\7n\2\2\u04b9\u00dc\3\2\2\2\u04ba"+ + "\u04bb\7x\2\2\u04bb\u04bc\7q\2\2\u04bc\u04bd\7k\2\2\u04bd\u04be\7f\2\2"+ + "\u04be\u00de\3\2\2\2\u04bf\u04c0\7x\2\2\u04c0\u04c1\7q\2\2\u04c1\u04c2"+ + "\7n\2\2\u04c2\u04c3\7c\2\2\u04c3\u04c4\7v\2\2\u04c4\u04c5\7k\2\2\u04c5"+ + "\u04c6\7n\2\2\u04c6\u04c7\7g\2\2\u04c7\u00e0\3\2\2\2\u04c8\u04c9\7y\2"+ + "\2\u04c9\u04ca\7j\2\2\u04ca\u04cb\7g\2\2\u04cb\u04cc\7p\2\2\u04cc\u00e2"+ + "\3\2\2\2\u04cd\u04ce\7y\2\2\u04ce\u04cf\7j\2\2\u04cf\u04d0\7g\2\2\u04d0"+ + "\u04d1\7t\2\2\u04d1\u04d2\7g\2\2\u04d2\u00e4\3\2\2\2\u04d3\u04d4\7y\2"+ + "\2\u04d4\u04d5\7j\2\2\u04d5\u04d6\7k\2\2\u04d6\u04d7\7n\2\2\u04d7\u04d8"+ + "\7g\2\2\u04d8\u00e6\3\2\2\2\u04d9\u04da\7{\2\2\u04da\u04db\7k\2\2\u04db"+ + "\u04dc\7g\2\2\u04dc\u04dd\7n\2\2\u04dd\u04de\7f\2\2\u04de\u00e8\3\2\2"+ + "\2\u04df\u04e1\7B\2\2\u04e0\u04df\3\2\2\2\u04e0\u04e1\3\2\2\2\u04e1\u04e2"+ + "\3\2\2\2\u04e2\u04e3\5\u01c5\u00e1\2\u04e3\u00ea\3\2\2\2\u04e4\u04ee\t"+ + "\3\2\2\u04e5\u04e7\7a\2\2\u04e6\u04e5\3\2\2\2\u04e7\u04ea\3\2\2\2\u04e8"+ + "\u04e6\3\2\2\2\u04e8\u04e9\3\2\2\2\u04e9\u04eb\3\2\2\2\u04ea\u04e8\3\2"+ + "\2\2\u04eb\u04ed\t\3\2\2\u04ec\u04e8\3\2\2\2\u04ed\u04f0\3\2\2\2\u04ee"+ + "\u04ec\3\2\2\2\u04ee\u04ef\3\2\2\2\u04ef\u04f2\3\2\2\2\u04f0\u04ee\3\2"+ + "\2\2\u04f1\u04f3\5\u01b5\u00d9\2\u04f2\u04f1\3\2\2\2\u04f2\u04f3\3\2\2"+ + "\2\u04f3\u04f4\3\2\2\2\u04f4\u04f6\7\60\2\2\u04f5\u04f7\7B\2\2\u04f6\u04f5"+ + "\3\2\2\2\u04f6\u04f7\3\2\2\2\u04f7\u04f8\3\2\2\2\u04f8\u04f9\5\u01c5\u00e1"+ + "\2\u04f9\u00ec\3\2\2\2\u04fa\u0504\t\3\2\2\u04fb\u04fd\7a\2\2\u04fc\u04fb"+ + "\3\2\2\2\u04fd\u0500\3\2\2\2\u04fe\u04fc\3\2\2\2\u04fe\u04ff\3\2\2\2\u04ff"+ + "\u0501\3\2\2\2\u0500\u04fe\3\2\2\2\u0501\u0503\t\3\2\2\u0502\u04fe\3\2"+ + "\2\2\u0503\u0506\3\2\2\2\u0504\u0502\3\2\2\2\u0504\u0505\3\2\2\2\u0505"+ + "\u0508\3\2\2\2\u0506\u0504\3\2\2\2\u0507\u0509\5\u01b5\u00d9\2\u0508\u0507"+ + "\3\2\2\2\u0508\u0509\3\2\2\2\u0509\u00ee\3\2\2\2\u050a\u050b\7\62\2\2"+ + "\u050b\u0513\t\4\2\2\u050c\u050e\7a\2\2\u050d\u050c\3\2\2\2\u050e\u0511"+ + "\3\2\2\2\u050f\u050d\3\2\2\2\u050f\u0510\3\2\2\2\u0510\u0512\3\2\2\2\u0511"+ + "\u050f\3\2\2\2\u0512\u0514\5\u01d7\u00ea\2\u0513\u050f\3\2\2\2\u0514\u0515"+ + "\3\2\2\2\u0515\u0513\3\2\2\2\u0515\u0516\3\2\2\2\u0516\u0518\3\2\2\2\u0517"+ + "\u0519\5\u01b5\u00d9\2\u0518\u0517\3\2\2\2\u0518\u0519\3\2\2\2\u0519\u00f0"+ + "\3\2\2\2\u051a\u051b\7\62\2\2\u051b\u0523\t\5\2\2\u051c\u051e\7a\2\2\u051d"+ + "\u051c\3\2\2\2\u051e\u0521\3\2\2\2\u051f\u051d\3\2\2\2\u051f\u0520\3\2"+ + "\2\2\u0520\u0522\3\2\2\2\u0521\u051f\3\2\2\2\u0522\u0524\t\6\2\2\u0523"+ + "\u051f\3\2\2\2\u0524\u0525\3\2\2\2\u0525\u0523\3\2\2\2\u0525\u0526\3\2"+ + "\2\2\u0526\u0528\3\2\2\2\u0527\u0529\5\u01b5\u00d9\2\u0528\u0527\3\2\2"+ + "\2\u0528\u0529\3\2\2\2\u0529\u00f2\3\2\2\2\u052a\u0534\t\3\2\2\u052b\u052d"+ + "\7a\2\2\u052c\u052b\3\2\2\2\u052d\u0530\3\2\2\2\u052e\u052c\3\2\2\2\u052e"+ + "\u052f\3\2\2\2\u052f\u0531\3\2\2\2\u0530\u052e\3\2\2\2\u0531\u0533\t\3"+ + "\2\2\u0532\u052e\3\2\2\2\u0533\u0536\3\2\2\2\u0534\u0532\3\2\2\2\u0534"+ + "\u0535\3\2\2\2\u0535\u0538\3\2\2\2\u0536\u0534\3\2\2\2\u0537\u052a\3\2"+ + "\2\2\u0537\u0538\3\2\2\2\u0538\u0539\3\2\2\2\u0539\u053a\7\60\2\2\u053a"+ + "\u0544\t\3\2\2\u053b\u053d\7a\2\2\u053c\u053b\3\2\2\2\u053d\u0540\3\2"+ + "\2\2\u053e\u053c\3\2\2\2\u053e\u053f\3\2\2\2\u053f\u0541\3\2\2\2\u0540"+ + "\u053e\3\2\2\2\u0541\u0543\t\3\2\2\u0542\u053e\3\2\2\2\u0543\u0546\3\2"+ + "\2\2\u0544\u0542\3\2\2\2\u0544\u0545\3\2\2\2\u0545\u0548\3\2\2\2\u0546"+ + "\u0544\3\2\2\2\u0547\u0549\5\u01b7\u00da\2\u0548\u0547\3\2\2\2\u0548\u0549"+ + "\3\2\2\2\u0549\u054b\3\2\2\2\u054a\u054c\t\7\2\2\u054b\u054a\3\2\2\2\u054b"+ + "\u054c\3\2\2\2\u054c\u0562\3\2\2\2\u054d\u0557\t\3\2\2\u054e\u0550\7a"+ + "\2\2\u054f\u054e\3\2\2\2\u0550\u0553\3\2\2\2\u0551\u054f\3\2\2\2\u0551"+ + "\u0552\3\2\2\2\u0552\u0554\3\2\2\2\u0553\u0551\3\2\2\2\u0554\u0556\t\3"+ + "\2\2\u0555\u0551\3\2\2\2\u0556\u0559\3\2\2\2\u0557\u0555\3\2\2\2\u0557"+ + "\u0558\3\2\2\2\u0558\u055f\3\2\2\2\u0559\u0557\3\2\2\2\u055a\u0560\t\7"+ + "\2\2\u055b\u055d\5\u01b7\u00da\2\u055c\u055e\t\7\2\2\u055d\u055c\3\2\2"+ + "\2\u055d\u055e\3\2\2\2\u055e\u0560\3\2\2\2\u055f\u055a\3\2\2\2\u055f\u055b"+ + "\3\2\2\2\u0560\u0562\3\2\2\2\u0561\u0537\3\2\2\2\u0561\u054d\3\2\2\2\u0562"+ + "\u00f4\3\2\2\2\u0563\u0566\7)\2\2\u0564\u0567\n\b\2\2\u0565\u0567\5\u01b9"+ + "\u00db\2\u0566\u0564\3\2\2\2\u0566\u0565\3\2\2\2\u0567\u0568\3\2\2\2\u0568"+ + "\u0569\7)\2\2\u0569\u00f6\3\2\2\2\u056a\u056f\7$\2\2\u056b\u056e\n\t\2"+ + "\2\u056c\u056e\5\u01b9\u00db\2\u056d\u056b\3\2\2\2\u056d\u056c\3\2\2\2"+ + "\u056e\u0571\3\2\2\2\u056f\u056d\3\2\2\2\u056f\u0570\3\2\2\2\u0570\u0572"+ + "\3\2\2\2\u0571\u056f\3\2\2\2\u0572\u0573\7$\2\2\u0573\u00f8\3\2\2\2\u0574"+ + "\u0575\7B\2\2\u0575\u0576\7$\2\2\u0576\u057c\3\2\2\2\u0577\u057b\n\n\2"+ + "\2\u0578\u0579\7$\2\2\u0579\u057b\7$\2\2\u057a\u0577\3\2\2\2\u057a\u0578"+ + "\3\2\2\2\u057b\u057e\3\2\2\2\u057c\u057a\3\2\2\2\u057c\u057d\3\2\2\2\u057d"+ + "\u057f\3\2\2\2\u057e\u057c\3\2\2\2\u057f\u0580\7$\2\2\u0580\u00fa\3\2"+ + "\2\2\u0581\u0582\7&\2\2\u0582\u0583\7$\2\2\u0583\u0584\3\2\2\2\u0584\u0585"+ + "\b|\5\2\u0585\u0586\3\2\2\2\u0586\u0587\b|\6\2\u0587\u00fc\3\2\2\2\u0588"+ + "\u0589\7&\2\2\u0589\u058a\7B\2\2\u058a\u058b\7$\2\2\u058b\u058c\3\2\2"+ + "\2\u058c\u058d\b}\7\2\u058d\u058e\3\2\2\2\u058e\u058f\b}\6\2\u058f\u00fe"+ + "\3\2\2\2\u0590\u0591\7}\2\2\u0591\u0592\b~\b\2\u0592\u0100\3\2\2\2\u0593"+ + "\u0594\7\177\2\2\u0594\u0595\b\177\t\2\u0595\u0102\3\2\2\2\u0596\u0597"+ + "\7]\2\2\u0597\u0104\3\2\2\2\u0598\u0599\7_\2\2\u0599\u0106\3\2\2\2\u059a"+ + "\u059b\7*\2\2\u059b\u0108\3\2\2\2\u059c\u059d\7+\2\2\u059d\u010a\3\2\2"+ + "\2\u059e\u059f\7\60\2\2\u059f\u010c\3\2\2\2\u05a0\u05a1\7.\2\2\u05a1\u010e"+ + "\3\2\2\2\u05a2\u05a3\7<\2\2\u05a3\u05a4\b\u0086\n\2\u05a4\u0110\3\2\2"+ + "\2\u05a5\u05a6\7=\2\2\u05a6\u0112\3\2\2\2\u05a7\u05a8\7-\2\2\u05a8\u0114"+ + "\3\2\2\2\u05a9\u05aa\7/\2\2\u05aa\u0116\3\2\2\2\u05ab\u05ac\7,\2\2\u05ac"+ + "\u0118\3\2\2\2\u05ad\u05ae\7\61\2\2\u05ae\u011a\3\2\2\2\u05af\u05b0\7"+ + "\'\2\2\u05b0\u011c\3\2\2\2\u05b1\u05b2\7(\2\2\u05b2\u011e\3\2\2\2\u05b3"+ + "\u05b4\7~\2\2\u05b4\u0120\3\2\2\2\u05b5\u05b6\7`\2\2\u05b6\u0122\3\2\2"+ + "\2\u05b7\u05b8\7#\2\2\u05b8\u0124\3\2\2\2\u05b9\u05ba\7\u0080\2\2\u05ba"+ + "\u0126\3\2\2\2\u05bb\u05bc\7?\2\2\u05bc\u0128\3\2\2\2\u05bd\u05be\7>\2"+ + "\2\u05be\u012a\3\2\2\2\u05bf\u05c0\7@\2\2\u05c0\u012c\3\2\2\2\u05c1\u05c2"+ + "\7A\2\2\u05c2\u012e\3\2\2\2\u05c3\u05c4\7<\2\2\u05c4\u05c5\7<\2\2\u05c5"+ + "\u0130\3\2\2\2\u05c6\u05c7\7A\2\2\u05c7\u05c8\7A\2\2\u05c8\u0132\3\2\2"+ + "\2\u05c9\u05ca\7-\2\2\u05ca\u05cb\7-\2\2\u05cb\u0134\3\2\2\2\u05cc\u05cd"+ + "\7/\2\2\u05cd\u05ce\7/\2\2\u05ce\u0136\3\2\2\2\u05cf\u05d0\7(\2\2\u05d0"+ + "\u05d1\7(\2\2\u05d1\u0138\3\2\2\2\u05d2\u05d3\7~\2\2\u05d3\u05d4\7~\2"+ + "\2\u05d4\u013a\3\2\2\2\u05d5\u05d6\7/\2\2\u05d6\u05d7\7@\2\2\u05d7\u013c"+ + "\3\2\2\2\u05d8\u05d9\7?\2\2\u05d9\u05da\7?\2\2\u05da\u013e\3\2\2\2\u05db"+ + "\u05dc\7#\2\2\u05dc\u05dd\7?\2\2\u05dd\u0140\3\2\2\2\u05de\u05df\7>\2"+ + "\2\u05df\u05e0\7?\2\2\u05e0\u0142\3\2\2\2\u05e1\u05e2\7@\2\2\u05e2\u05e3"+ + "\7?\2\2\u05e3\u0144\3\2\2\2\u05e4\u05e5\7-\2\2\u05e5\u05e6\7?\2\2\u05e6"+ + "\u0146\3\2\2\2\u05e7\u05e8\7/\2\2\u05e8\u05e9\7?\2\2\u05e9\u0148\3\2\2"+ + "\2\u05ea\u05eb\7,\2\2\u05eb\u05ec\7?\2\2\u05ec\u014a\3\2\2\2\u05ed\u05ee"+ + "\7\61\2\2\u05ee\u05ef\7?\2\2\u05ef\u014c\3\2\2\2\u05f0\u05f1\7\'\2\2\u05f1"+ + "\u05f2\7?\2\2\u05f2\u014e\3\2\2\2\u05f3\u05f4\7(\2\2\u05f4\u05f5\7?\2"+ + "\2\u05f5\u0150\3\2\2\2\u05f6\u05f7\7~\2\2\u05f7\u05f8\7?\2\2\u05f8\u0152"+ + "\3\2\2\2\u05f9\u05fa\7`\2\2\u05fa\u05fb\7?\2\2\u05fb\u0154\3\2\2\2\u05fc"+ + "\u05fd\7>\2\2\u05fd\u05fe\7>\2\2\u05fe\u0156\3\2\2\2\u05ff\u0600\7>\2"+ + "\2\u0600\u0601\7>\2\2\u0601\u0602\7?\2\2\u0602\u0158\3\2\2\2\u0603\u0604"+ + "\7A\2\2\u0604\u0605\7A\2\2\u0605\u0606\7?\2\2\u0606\u015a\3\2\2\2\u0607"+ + "\u0608\7\60\2\2\u0608\u0609\7\60\2\2\u0609\u015c\3\2\2\2\u060a\u060b\7"+ + "}\2\2\u060b\u060c\7}\2\2\u060c\u015e\3\2\2\2\u060d\u060e\7}\2\2\u060e"+ + "\u060f\b\u00ae\13\2\u060f\u0610\3\2\2\2\u0610\u0611\b\u00ae\f\2\u0611"+ + "\u0612\b\u00ae\r\2\u0612\u0160\3\2\2\2\u0613\u0614\6\u00af\2\2\u0614\u0615"+ + "\5\u01bb\u00dc\2\u0615\u0162\3\2\2\2\u0616\u0617\6\u00b0\3\2\u0617\u0618"+ + "\7$\2\2\u0618\u0619\7$\2\2\u0619\u0164\3\2\2\2\u061a\u061b\7$\2\2\u061b"+ + "\u061c\b\u00b1\16\2\u061c\u061d\3\2\2\2\u061d\u061e\b\u00b1\17\2\u061e"+ + "\u0166\3\2\2\2\u061f\u0621\6\u00b2\4\2\u0620\u0622\n\13\2\2\u0621\u0620"+ + "\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0621\3\2\2\2\u0623\u0624\3\2\2\2\u0624"+ + "\u0168\3\2\2\2\u0625\u0627\6\u00b3\5\2\u0626\u0628\n\f\2\2\u0627\u0626"+ + "\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u0627\3\2\2\2\u0629\u062a\3\2\2\2\u062a"+ + "\u016a\3\2\2\2\u062b\u062c\7\177\2\2\u062c\u062d\7\177\2\2\u062d\u062e"+ + "\3\2\2\2\u062e\u062f\b\u00b4\20\2\u062f\u016c\3\2\2\2\u0630\u0631\7\177"+ + "\2\2\u0631\u0632\b\u00b5\21\2\u0632\u0633\3\2\2\2\u0633\u0634\b\u00b5"+ + "\f\2\u0634\u0635\b\u00b5\17\2\u0635\u016e\3\2\2\2\u0636\u0638\n\r\2\2"+ + "\u0637\u0636\3\2\2\2\u0638\u0639\3\2\2\2\u0639\u0637\3\2\2\2\u0639\u063a"+ + "\3\2\2\2\u063a\u0170\3\2\2\2\u063b\u063d\5\u01c1\u00df\2\u063c\u063b\3"+ + "\2\2\2\u063d\u063e\3\2\2\2\u063e\u063c\3\2\2\2\u063e\u063f\3\2\2\2\u063f"+ + "\u0640\3\2\2\2\u0640\u0641\b\u00b7\3\2\u0641\u0172\3\2\2\2\u0642\u0644"+ + "\t\3\2\2\u0643\u0642\3\2\2\2\u0644\u0645\3\2\2\2\u0645\u0643\3\2\2\2\u0645"+ + "\u0646\3\2\2\2\u0646\u0647\3\2\2\2\u0647\u0648\b\u00b8\22\2\u0648\u0174"+ + "\3\2\2\2\u0649\u064a\7v\2\2\u064a\u064b\7t\2\2\u064b\u064c\7w\2\2\u064c"+ + "\u064d\7g\2\2\u064d\u064e\3\2\2\2\u064e\u064f\b\u00b9\22\2\u064f\u0650"+ + "\b\u00b9\23\2\u0650\u0176\3\2\2\2\u0651\u0652\7h\2\2\u0652\u0653\7c\2"+ + "\2\u0653\u0654\7n\2\2\u0654\u0655\7u\2\2\u0655\u0656\7g\2\2\u0656\u0657"+ + "\3\2\2\2\u0657\u0658\b\u00ba\22\2\u0658\u0659\b\u00ba\24\2\u0659\u0178"+ + "\3\2\2\2\u065a\u065b\7f\2\2\u065b\u065c\7g\2\2\u065c\u065d\7h\2\2\u065d"+ + "\u065e\7k\2\2\u065e\u065f\7p\2\2\u065f\u0660\7g\2\2\u0660\u0661\3\2\2"+ + "\2\u0661\u0662\b\u00bb\22\2\u0662\u017a\3\2\2\2\u0663\u0664\7w\2\2\u0664"+ + "\u0665\7p\2\2\u0665\u0666\7f\2\2\u0666\u0667\7g\2\2\u0667\u0668\7h\2\2"+ + "\u0668\u0669\3\2\2\2\u0669\u066a\b\u00bc\22\2\u066a\u017c\3\2\2\2\u066b"+ + "\u066c\7k\2\2\u066c\u066d\7h\2\2\u066d\u066e\3\2\2\2\u066e\u066f\b\u00bd"+ + "\22\2\u066f\u0670\b\u00bd\25\2\u0670\u017e\3\2\2\2\u0671\u0672\7g\2\2"+ + "\u0672\u0673\7n\2\2\u0673\u0674\7k\2\2\u0674\u0675\7h\2\2\u0675\u0676"+ + "\3\2\2\2\u0676\u0677\b\u00be\22\2\u0677\u0180\3\2\2\2\u0678\u0679\7g\2"+ + "\2\u0679\u067a\7n\2\2\u067a\u067b\7u\2\2\u067b\u067c\7g\2\2\u067c\u067d"+ + "\3\2\2\2\u067d\u067e\b\u00bf\22\2\u067e\u067f\b\u00bf\26\2\u067f\u0182"+ + "\3\2\2\2\u0680\u0681\7g\2\2\u0681\u0682\7p\2\2\u0682\u0683\7f\2\2\u0683"+ + "\u0684\7k\2\2\u0684\u0685\7h\2\2\u0685\u0686\3\2\2\2\u0686\u0687\b\u00c0"+ + "\22\2\u0687\u0184\3\2\2\2\u0688\u0689\7n\2\2\u0689\u068a\7k\2\2\u068a"+ + "\u068b\7p\2\2\u068b\u068c\7g\2\2\u068c\u068d\3\2\2\2\u068d\u068e\b\u00c1"+ + "\22\2\u068e\u0186\3\2\2\2\u068f\u0690\7g\2\2\u0690\u0691\7t\2\2\u0691"+ + "\u0692\7t\2\2\u0692\u0693\7q\2\2\u0693\u0694\7t\2\2\u0694\u0696\3\2\2"+ + "\2\u0695\u0697\5\u01c1\u00df\2\u0696\u0695\3\2\2\2\u0697\u0698\3\2\2\2"+ + "\u0698\u0696\3\2\2\2\u0698\u0699\3\2\2\2\u0699\u069a\3\2\2\2\u069a\u069b"+ + "\b\u00c2\22\2\u069b\u069c\b\u00c2\27\2\u069c\u0188\3\2\2\2\u069d\u069e"+ + "\7y\2\2\u069e\u069f\7c\2\2\u069f\u06a0\7t\2\2\u06a0\u06a1\7p\2\2\u06a1"+ + "\u06a2\7k\2\2\u06a2\u06a3\7p\2\2\u06a3\u06a4\7i\2\2\u06a4\u06a6\3\2\2"+ + "\2\u06a5\u06a7\5\u01c1\u00df\2\u06a6\u06a5\3\2\2\2\u06a7\u06a8\3\2\2\2"+ + "\u06a8\u06a6\3\2\2\2\u06a8\u06a9\3\2\2\2\u06a9\u06aa\3\2\2\2\u06aa\u06ab"+ + "\b\u00c3\22\2\u06ab\u06ac\b\u00c3\27\2\u06ac\u018a\3\2\2\2\u06ad\u06ae"+ + "\7t\2\2\u06ae\u06af\7g\2\2\u06af\u06b0\7i\2\2\u06b0\u06b1\7k\2\2\u06b1"+ + "\u06b2\7q\2\2\u06b2\u06b3\7p\2\2\u06b3\u06b7\3\2\2\2\u06b4\u06b6\5\u01c1"+ + "\u00df\2\u06b5\u06b4\3\2\2\2\u06b6\u06b9\3\2\2\2\u06b7\u06b5\3\2\2\2\u06b7"+ + "\u06b8\3\2\2\2\u06b8\u06ba\3\2\2\2\u06b9\u06b7\3\2\2\2\u06ba\u06bb\b\u00c4"+ + "\22\2\u06bb\u06bc\b\u00c4\27\2\u06bc\u018c\3\2\2\2\u06bd\u06be\7g\2\2"+ + "\u06be\u06bf\7p\2\2\u06bf\u06c0\7f\2\2\u06c0\u06c1\7t\2\2\u06c1\u06c2"+ + "\7g\2\2\u06c2\u06c3\7i\2\2\u06c3\u06c4\7k\2\2\u06c4\u06c5\7q\2\2\u06c5"+ + "\u06c6\7p\2\2\u06c6\u06ca\3\2\2\2\u06c7\u06c9\5\u01c1\u00df\2\u06c8\u06c7"+ + "\3\2\2\2\u06c9\u06cc\3\2\2\2\u06ca\u06c8\3\2\2\2\u06ca\u06cb\3\2\2\2\u06cb"+ + "\u06cd\3\2\2\2\u06cc\u06ca\3\2\2\2\u06cd\u06ce\b\u00c5\22\2\u06ce\u06cf"+ + "\b\u00c5\27\2\u06cf\u018e\3\2\2\2\u06d0\u06d1\7r\2\2\u06d1\u06d2\7t\2"+ + "\2\u06d2\u06d3\7c\2\2\u06d3\u06d4\7i\2\2\u06d4\u06d5\7o\2\2\u06d5\u06d6"+ + "\7c\2\2\u06d6\u06d8\3\2\2\2\u06d7\u06d9\5\u01c1\u00df\2\u06d8\u06d7\3"+ + "\2\2\2\u06d9\u06da\3\2\2\2\u06da\u06d8\3\2\2\2\u06da\u06db\3\2\2\2\u06db"+ + "\u06dc\3\2\2\2\u06dc\u06dd\b\u00c6\22\2\u06dd\u06de\b\u00c6\27\2\u06de"+ + "\u0190\3\2\2\2\u06df\u06e0\7p\2\2\u06e0\u06e1\7w\2\2\u06e1\u06e2\7n\2"+ + "\2\u06e2\u06e3\7n\2\2\u06e3\u06e4\7c\2\2\u06e4\u06e5\7d\2\2\u06e5\u06e6"+ + "\7n\2\2\u06e6\u06e7\7g\2\2\u06e7\u06e9\3\2\2\2\u06e8\u06ea\5\u01c1\u00df"+ + "\2\u06e9\u06e8\3\2\2\2\u06ea\u06eb\3\2\2\2\u06eb\u06e9\3\2\2\2\u06eb\u06ec"+ + "\3\2\2\2\u06ec\u06ed\3\2\2\2\u06ed\u06ee\b\u00c7\22\2\u06ee\u06ef\b\u00c7"+ + "\27\2\u06ef\u0192\3\2\2\2\u06f0\u06f1\7f\2\2\u06f1\u06f2\7g\2\2\u06f2"+ + "\u06f3\7h\2\2\u06f3\u06f4\7c\2\2\u06f4\u06f5\7w\2\2\u06f5\u06f6\7n\2\2"+ + "\u06f6\u06f7\7v\2\2\u06f7\u06f8\3\2\2\2\u06f8\u06f9\b\u00c8\22\2\u06f9"+ + "\u06fa\b\u00c8\30\2\u06fa\u0194\3\2\2\2\u06fb\u06fc\7j\2\2\u06fc\u06fd"+ + "\7k\2\2\u06fd\u06fe\7f\2\2\u06fe\u06ff\7f\2\2\u06ff\u0700\7g\2\2\u0700"+ + "\u0701\7p\2\2\u0701\u0702\3\2\2\2\u0702\u0703\b\u00c9\22\2\u0703\u0196"+ + "\3\2\2\2\u0704\u0705\7*\2\2\u0705\u0706\3\2\2\2\u0706\u0707\b\u00ca\22"+ + "\2\u0707\u0708\b\u00ca\31\2\u0708\u0198\3\2\2\2\u0709\u070a\7+\2\2\u070a"+ + "\u070b\3\2\2\2\u070b\u070c\b\u00cb\22\2\u070c\u070d\b\u00cb\32\2\u070d"+ + "\u019a\3\2\2\2\u070e\u070f\7#\2\2\u070f\u0710\3\2\2\2\u0710\u0711\b\u00cc"+ + "\22\2\u0711\u0712\b\u00cc\33\2\u0712\u019c\3\2\2\2\u0713\u0714\7?\2\2"+ + "\u0714\u0715\7?\2\2\u0715\u0716\3\2\2\2\u0716\u0717\b\u00cd\22\2\u0717"+ + "\u0718\b\u00cd\34\2\u0718\u019e\3\2\2\2\u0719\u071a\7#\2\2\u071a\u071b"+ + "\7?\2\2\u071b\u071c\3\2\2\2\u071c\u071d\b\u00ce\22\2\u071d\u071e\b\u00ce"+ + "\35\2\u071e\u01a0\3\2\2\2\u071f\u0720\7(\2\2\u0720\u0721\7(\2\2\u0721"+ + "\u0722\3\2\2\2\u0722\u0723\b\u00cf\22\2\u0723\u0724\b\u00cf\36\2\u0724"+ + "\u01a2\3\2\2\2\u0725\u0726\7~\2\2\u0726\u0727\7~\2\2\u0727\u0728\3\2\2"+ + "\2\u0728\u0729\b\u00d0\22\2\u0729\u072a\b\u00d0\37\2\u072a\u01a4\3\2\2"+ + "\2\u072b\u072f\7$\2\2\u072c\u072e\n\16\2\2\u072d\u072c\3\2\2\2\u072e\u0731"+ + "\3\2\2\2\u072f\u072d\3\2\2\2\u072f\u0730\3\2\2\2\u0730\u0732\3\2\2\2\u0731"+ + "\u072f\3\2\2\2\u0732\u0733\7$\2\2\u0733\u0734\3\2\2\2\u0734\u0735\b\u00d1"+ + "\22\2\u0735\u0736\b\u00d1 \2\u0736\u01a6\3\2\2\2\u0737\u0738\5\u01c5\u00e1"+ + "\2\u0738\u0739\3\2\2\2\u0739\u073a\b\u00d2\22\2\u073a\u01a8\3\2\2\2\u073b"+ + "\u073c\7\61\2\2\u073c\u073d\7\61\2\2\u073d\u0741\3\2\2\2\u073e\u0740\n"+ + "\17\2\2\u073f\u073e\3\2\2\2\u0740\u0743\3\2\2\2\u0741\u073f\3\2\2\2\u0741"+ + "\u0742\3\2\2\2\u0742\u0744\3\2\2\2\u0743\u0741\3\2\2\2\u0744\u0745\b\u00d3"+ + "\2\2\u0745\u0746\b\u00d3!\2\u0746\u01aa\3\2\2\2\u0747\u0748\5\u01bf\u00de"+ + "\2\u0748\u0749\3\2\2\2\u0749\u074a\b\u00d4\22\2\u074a\u074b\b\u00d4\""+ + "\2\u074b\u01ac\3\2\2\2\u074c\u074e\n\17\2\2\u074d\u074c\3\2\2\2\u074e"+ + "\u074f\3\2\2\2\u074f\u074d\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u0751\3\2"+ + "\2\2\u0751\u0752\b\u00d5\22\2\u0752\u01ae\3\2\2\2\u0753\u0754\5\u01bf"+ + "\u00de\2\u0754\u0755\3\2\2\2\u0755\u0756\b\u00d6\22\2\u0756\u0757\b\u00d6"+ + "#\2\u0757\u0758\b\u00d6\"\2\u0758\u01b0\3\2\2\2\u0759\u075a\n\17\2\2\u075a"+ + "\u01b2\3\2\2\2\u075b\u075c\t\17\2\2\u075c\u01b4\3\2\2\2\u075d\u075f\t"+ + "\20\2\2\u075e\u075d\3\2\2\2\u075e\u075f\3\2\2\2\u075f\u0760\3\2\2\2\u0760"+ + "\u0766\t\21\2\2\u0761\u0763\t\21\2\2\u0762\u0761\3\2\2\2\u0762\u0763\3"+ + "\2\2\2\u0763\u0764\3\2\2\2\u0764\u0766\t\20\2\2\u0765\u075e\3\2\2\2\u0765"+ + "\u0762\3\2\2\2\u0766\u01b6\3\2\2\2\u0767\u0769\t\22\2\2\u0768\u076a\t"+ + "\23\2\2\u0769\u0768\3\2\2\2\u0769\u076a\3\2\2\2\u076a\u076b\3\2\2\2\u076b"+ + "\u0775\t\3\2\2\u076c\u076e\7a\2\2\u076d\u076c\3\2\2\2\u076e\u0771\3\2"+ + "\2\2\u076f\u076d\3\2\2\2\u076f\u0770\3\2\2\2\u0770\u0772\3\2\2\2\u0771"+ + "\u076f\3\2\2\2\u0772\u0774\t\3\2\2\u0773\u076f\3\2\2\2\u0774\u0777\3\2"+ + "\2\2\u0775\u0773\3\2\2\2\u0775\u0776\3\2\2\2\u0776\u01b8\3\2\2\2\u0777"+ + "\u0775\3\2\2\2\u0778\u077c\5\u01bb\u00dc\2\u0779\u077c\5\u01bd\u00dd\2"+ + "\u077a\u077c\5\u01d5\u00e9\2\u077b\u0778\3\2\2\2\u077b\u0779\3\2\2\2\u077b"+ + "\u077a\3\2\2\2\u077c\u01ba\3\2\2\2\u077d\u077e\7^\2\2\u077e\u0794\7)\2"+ + "\2\u077f\u0780\7^\2\2\u0780\u0794\7$\2\2\u0781\u0782\7^\2\2\u0782\u0794"+ + "\7^\2\2\u0783\u0784\7^\2\2\u0784\u0794\7\62\2\2\u0785\u0786\7^\2\2\u0786"+ + "\u0794\7c\2\2\u0787\u0788\7^\2\2\u0788\u0794\7d\2\2\u0789\u078a\7^\2\2"+ + "\u078a\u0794\7h\2\2\u078b\u078c\7^\2\2\u078c\u0794\7p\2\2\u078d\u078e"+ + "\7^\2\2\u078e\u0794\7t\2\2\u078f\u0790\7^\2\2\u0790\u0794\7v\2\2\u0791"+ + "\u0792\7^\2\2\u0792\u0794\7x\2\2\u0793\u077d\3\2\2\2\u0793\u077f\3\2\2"+ + "\2\u0793\u0781\3\2\2\2\u0793\u0783\3\2\2\2\u0793\u0785\3\2\2\2\u0793\u0787"+ + "\3\2\2\2\u0793\u0789\3\2\2\2\u0793\u078b\3\2\2\2\u0793\u078d\3\2\2\2\u0793"+ + "\u078f\3\2\2\2\u0793\u0791\3\2\2\2\u0794\u01bc\3\2\2\2\u0795\u0796\7^"+ + "\2\2\u0796\u0797\7z\2\2\u0797\u0798\3\2\2\2\u0798\u07af\5\u01d7\u00ea"+ + "\2\u0799\u079a\7^\2\2\u079a\u079b\7z\2\2\u079b\u079c\3\2\2\2\u079c\u079d"+ + "\5\u01d7\u00ea\2\u079d\u079e\5\u01d7\u00ea\2\u079e\u07af\3\2\2\2\u079f"+ + "\u07a0\7^\2\2\u07a0\u07a1\7z\2\2\u07a1\u07a2\3\2\2\2\u07a2\u07a3\5\u01d7"+ + "\u00ea\2\u07a3\u07a4\5\u01d7\u00ea\2\u07a4\u07a5\5\u01d7\u00ea\2\u07a5"+ + "\u07af\3\2\2\2\u07a6\u07a7\7^\2\2\u07a7\u07a8\7z\2\2\u07a8\u07a9\3\2\2"+ + "\2\u07a9\u07aa\5\u01d7\u00ea\2\u07aa\u07ab\5\u01d7\u00ea\2\u07ab\u07ac"+ + "\5\u01d7\u00ea\2\u07ac\u07ad\5\u01d7\u00ea\2\u07ad\u07af\3\2\2\2\u07ae"+ + "\u0795\3\2\2\2\u07ae\u0799\3\2\2\2\u07ae\u079f\3\2\2\2\u07ae\u07a6\3\2"+ + "\2\2\u07af\u01be\3\2\2\2\u07b0\u07b1\7\17\2\2\u07b1\u07b4\7\f\2\2\u07b2"+ + "\u07b4\t\17\2\2\u07b3\u07b0\3\2\2\2\u07b3\u07b2\3\2\2\2\u07b4\u01c0\3"+ + "\2\2\2\u07b5\u07b8\5\u01c3\u00e0\2\u07b6\u07b8\t\24\2\2\u07b7\u07b5\3"+ + "\2\2\2\u07b7\u07b6\3\2\2\2\u07b8\u01c2\3\2\2\2\u07b9\u07ba\t\25\2\2\u07ba"+ + "\u01c4\3\2\2\2\u07bb\u07bf\5\u01c7\u00e2\2\u07bc\u07be\5\u01c9\u00e3\2"+ + "\u07bd\u07bc\3\2\2\2\u07be\u07c1\3\2\2\2\u07bf\u07bd\3\2\2\2\u07bf\u07c0"+ + "\3\2\2\2\u07c0\u01c6\3\2\2\2\u07c1\u07bf\3\2\2\2\u07c2\u07c5\5\u01cb\u00e4"+ + "\2\u07c3\u07c5\7a\2\2\u07c4\u07c2\3\2\2\2\u07c4\u07c3\3\2\2\2\u07c5\u01c8"+ + "\3\2\2\2\u07c6\u07cc\5\u01cb\u00e4\2\u07c7\u07cc\5\u01cd\u00e5\2\u07c8"+ + "\u07cc\5\u01cf\u00e6\2\u07c9\u07cc\5\u01d1\u00e7\2\u07ca\u07cc\5\u01d3"+ + "\u00e8\2\u07cb\u07c6\3\2\2\2\u07cb\u07c7\3\2\2\2\u07cb\u07c8\3\2\2\2\u07cb"+ + "\u07c9\3\2\2\2\u07cb\u07ca\3\2\2\2\u07cc\u01ca\3\2\2\2\u07cd\u07d5\5\u01d9"+ + "\u00eb\2\u07ce\u07d5\5\u01db\u00ec\2\u07cf\u07d5\5\u01dd\u00ed\2\u07d0"+ + "\u07d5\5\u01df\u00ee\2\u07d1\u07d5\5\u01e1\u00ef\2\u07d2\u07d5\5\u01e3"+ + "\u00f0\2\u07d3\u07d5\5\u01d5\u00e9\2\u07d4\u07cd\3\2\2\2\u07d4\u07ce\3"+ + "\2\2\2\u07d4\u07cf\3\2\2\2\u07d4\u07d0\3\2\2\2\u07d4\u07d1\3\2\2\2\u07d4"+ + "\u07d2\3\2\2\2\u07d4\u07d3\3\2\2\2\u07d5\u01cc\3\2\2\2\u07d6\u07d9\5\u01ed"+ + "\u00f5\2\u07d7\u07d9\5\u01d5\u00e9\2\u07d8\u07d6\3\2\2\2\u07d8\u07d7\3"+ + "\2\2\2\u07d9\u01ce\3\2\2\2\u07da\u07dd\5\u01eb\u00f4\2\u07db\u07dd\5\u01d5"+ + "\u00e9\2\u07dc\u07da\3\2\2\2\u07dc\u07db\3\2\2\2\u07dd\u01d0\3\2\2\2\u07de"+ + "\u07e2\5\u01e5\u00f1\2\u07df\u07e2\5\u01e7\u00f2\2\u07e0\u07e2\5\u01d5"+ + "\u00e9\2\u07e1\u07de\3\2\2\2\u07e1\u07df\3\2\2\2\u07e1\u07e0\3\2\2\2\u07e2"+ + "\u01d2\3\2\2\2\u07e3\u07e6\5\u01e9\u00f3\2\u07e4\u07e6\5\u01d5\u00e9\2"+ + "\u07e5\u07e3\3\2\2\2\u07e5\u07e4\3\2\2\2\u07e6\u01d4\3\2\2\2\u07e7\u07e8"+ + "\7^\2\2\u07e8\u07e9\7w\2\2\u07e9\u07ea\3\2\2\2\u07ea\u07eb\5\u01d7\u00ea"+ + "\2\u07eb\u07ec\5\u01d7\u00ea\2\u07ec\u07ed\5\u01d7\u00ea\2\u07ed\u07ee"+ + "\5\u01d7\u00ea\2\u07ee\u07fc\3\2\2\2\u07ef\u07f0\7^\2\2\u07f0\u07f1\7"+ + "W\2\2\u07f1\u07f2\3\2\2\2\u07f2\u07f3\5\u01d7\u00ea\2\u07f3\u07f4\5\u01d7"+ + "\u00ea\2\u07f4\u07f5\5\u01d7\u00ea\2\u07f5\u07f6\5\u01d7\u00ea\2\u07f6"+ + "\u07f7\5\u01d7\u00ea\2\u07f7\u07f8\5\u01d7\u00ea\2\u07f8\u07f9\5\u01d7"+ + "\u00ea\2\u07f9\u07fa\5\u01d7\u00ea\2\u07fa\u07fc\3\2\2\2\u07fb\u07e7\3"+ + "\2\2\2\u07fb\u07ef\3\2\2\2\u07fc\u01d6\3\2\2\2\u07fd\u07ff\t\26\2\2\u07fe"+ + "\u07fd\3\2\2\2\u07ff\u01d8\3\2\2\2\u0800\u0801\t\27\2\2\u0801\u01da\3"+ + "\2\2\2\u0802\u0803\t\30\2\2\u0803\u01dc\3\2\2\2\u0804\u0805\t\31\2\2\u0805"+ + "\u01de\3\2\2\2\u0806\u0807\t\32\2\2\u0807\u01e0\3\2\2\2\u0808\u0809\t"+ + "\33\2\2\u0809\u01e2\3\2\2\2\u080a\u080b\t\34\2\2\u080b\u01e4\3\2\2\2\u080c"+ + "\u080d\4\u0302\u0312\2\u080d\u01e6\3\2\2\2\u080e\u080f\t\35\2\2\u080f"+ + "\u01e8\3\2\2\2\u0810\u0811\t\36\2\2\u0811\u01ea\3\2\2\2\u0812\u0813\t"+ + "\37\2\2\u0813\u01ec\3\2\2\2\u0814\u0815\t \2\2\u0815\u01ee\3\2\2\2O\2"+ + "\3\4\5\6\u01fa\u020f\u021d\u0228\u0232\u0234\u04e0\u04e8\u04ee\u04f2\u04f6"+ + "\u04fe\u0504\u0508\u050f\u0515\u0518\u051f\u0525\u0528\u052e\u0534\u0537"+ + "\u053e\u0544\u0548\u054b\u0551\u0557\u055d\u055f\u0561\u0566\u056d\u056f"+ + "\u057a\u057c\u0623\u0629\u0639\u063e\u0645\u0698\u06a8\u06b7\u06ca\u06da"+ + "\u06eb\u072f\u0741\u074f\u075e\u0762\u0765\u0769\u076f\u0775\u077b\u0793"+ + "\u07ae\u07b3\u07b7\u07bf\u07c4\u07cb\u07d4\u07d8\u07dc\u07e1\u07e5\u07fb"+ + "\u07fe$\2\4\2\2\3\2\4\5\2\3|\2\7\3\2\3}\3\3~\4\3\177\5\3\u0086\6\3\u00ae"+ + "\7\b\2\2\7\2\2\3\u00b1\b\6\2\2\t\u00b6\2\3\u00b5\t\2\5\2\tb\2\t,\2\t\66"+ + "\2\t&\2\4\6\2\t \2\t\u0083\2\t\u0084\2\t\u0091\2\t\u009e\2\t\u009f\2\t"+ + "\u009b\2\t\u009c\2\t]\2\t\7\2\4\2\2\t\u00c6\2"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpParser.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpParser.java new file mode 100644 index 0000000000..9ab49d0715 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpParser.java @@ -0,0 +1,20407 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.antlr; + +// Generated from CSharpParser.g4 by ANTLR 4.9.2 +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class CSharpParser extends Parser { + static { RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + BYTE_ORDER_MARK=1, SINGLE_LINE_DOC_COMMENT=2, EMPTY_DELIMITED_DOC_COMMENT=3, + DELIMITED_DOC_COMMENT=4, SINGLE_LINE_COMMENT=5, DELIMITED_COMMENT=6, WHITESPACES=7, + SHARP=8, ABSTRACT=9, ADD=10, ALIAS=11, ARGLIST=12, AS=13, ASCENDING=14, + ASYNC=15, AWAIT=16, BASE=17, BOOL=18, BREAK=19, BY=20, BYTE=21, CASE=22, + CATCH=23, CHAR=24, CHECKED=25, CLASS=26, CONST=27, CONTINUE=28, DECIMAL=29, + DEFAULT=30, DELEGATE=31, DESCENDING=32, DO=33, DOUBLE=34, DYNAMIC=35, + ELSE=36, ENUM=37, EQUALS=38, EVENT=39, EXPLICIT=40, EXTERN=41, FALSE=42, + FINALLY=43, FIXED=44, FLOAT=45, FOR=46, FOREACH=47, FROM=48, GET=49, GOTO=50, + GROUP=51, IF=52, IMPLICIT=53, IN=54, INT=55, INTERFACE=56, INTERNAL=57, + INTO=58, IS=59, JOIN=60, LET=61, LOCK=62, LONG=63, NAMEOF=64, NAMESPACE=65, + NEW=66, NULL_=67, OBJECT=68, ON=69, OPERATOR=70, ORDERBY=71, OUT=72, OVERRIDE=73, + PARAMS=74, PARTIAL=75, PRIVATE=76, PROTECTED=77, PUBLIC=78, READONLY=79, + REF=80, REMOVE=81, RETURN=82, SBYTE=83, SEALED=84, SELECT=85, SET=86, + SHORT=87, SIZEOF=88, STACKALLOC=89, STATIC=90, STRING=91, STRUCT=92, SWITCH=93, + THIS=94, THROW=95, TRUE=96, TRY=97, TYPEOF=98, UINT=99, ULONG=100, UNCHECKED=101, + UNMANAGED=102, UNSAFE=103, USHORT=104, USING=105, VAR=106, VIRTUAL=107, + VOID=108, VOLATILE=109, WHEN=110, WHERE=111, WHILE=112, YIELD=113, IDENTIFIER=114, + LITERAL_ACCESS=115, INTEGER_LITERAL=116, HEX_INTEGER_LITERAL=117, BIN_INTEGER_LITERAL=118, + REAL_LITERAL=119, CHARACTER_LITERAL=120, REGULAR_STRING=121, VERBATIUM_STRING=122, + INTERPOLATED_REGULAR_STRING_START=123, INTERPOLATED_VERBATIUM_STRING_START=124, + OPEN_BRACE=125, CLOSE_BRACE=126, OPEN_BRACKET=127, CLOSE_BRACKET=128, + OPEN_PARENS=129, CLOSE_PARENS=130, DOT=131, COMMA=132, COLON=133, SEMICOLON=134, + PLUS=135, MINUS=136, STAR=137, DIV=138, PERCENT=139, AMP=140, BITWISE_OR=141, + CARET=142, BANG=143, TILDE=144, ASSIGNMENT=145, LT=146, GT=147, INTERR=148, + DOUBLE_COLON=149, OP_COALESCING=150, OP_INC=151, OP_DEC=152, OP_AND=153, + OP_OR=154, OP_PTR=155, OP_EQ=156, OP_NE=157, OP_LE=158, OP_GE=159, OP_ADD_ASSIGNMENT=160, + OP_SUB_ASSIGNMENT=161, OP_MULT_ASSIGNMENT=162, OP_DIV_ASSIGNMENT=163, + OP_MOD_ASSIGNMENT=164, OP_AND_ASSIGNMENT=165, OP_OR_ASSIGNMENT=166, OP_XOR_ASSIGNMENT=167, + OP_LEFT_SHIFT=168, OP_LEFT_SHIFT_ASSIGNMENT=169, OP_COALESCING_ASSIGNMENT=170, + OP_RANGE=171, DOUBLE_CURLY_INSIDE=172, OPEN_BRACE_INSIDE=173, REGULAR_CHAR_INSIDE=174, + VERBATIUM_DOUBLE_QUOTE_INSIDE=175, DOUBLE_QUOTE_INSIDE=176, REGULAR_STRING_INSIDE=177, + VERBATIUM_INSIDE_STRING=178, CLOSE_BRACE_INSIDE=179, FORMAT_STRING=180, + DIRECTIVE_WHITESPACES=181, DIGITS=182, DEFINE=183, UNDEF=184, ELIF=185, + ENDIF=186, LINE=187, ERROR=188, WARNING=189, REGION=190, ENDREGION=191, + PRAGMA=192, NULLABLE=193, DIRECTIVE_HIDDEN=194, CONDITIONAL_SYMBOL=195, + DIRECTIVE_NEW_LINE=196, TEXT=197, DOUBLE_CURLY_CLOSE_INSIDE=198; + public static final int + RULE_compilation_unit = 0, RULE_namespace_or_type_name = 1, RULE_type_ = 2, + RULE_base_type = 3, RULE_tuple_type = 4, RULE_tuple_element = 5, RULE_simple_type = 6, + RULE_numeric_type = 7, RULE_integral_type = 8, RULE_floating_point_type = 9, + RULE_class_type = 10, RULE_type_argument_list = 11, RULE_argument_list = 12, + RULE_argument = 13, RULE_expression = 14, RULE_non_assignment_expression = 15, + RULE_assignment = 16, RULE_assignment_operator = 17, RULE_conditional_expression = 18, + RULE_null_coalescing_expression = 19, RULE_conditional_or_expression = 20, + RULE_conditional_and_expression = 21, RULE_inclusive_or_expression = 22, + RULE_exclusive_or_expression = 23, RULE_and_expression = 24, RULE_equality_expression = 25, + RULE_relational_expression = 26, RULE_shift_expression = 27, RULE_additive_expression = 28, + RULE_multiplicative_expression = 29, RULE_switch_expression = 30, RULE_switch_expression_arms = 31, + RULE_switch_expression_arm = 32, RULE_range_expression = 33, RULE_unary_expression = 34, + RULE_primary_expression = 35, RULE_primary_expression_start = 36, RULE_throwable_expression = 37, + RULE_throw_expression = 38, RULE_member_access = 39, RULE_bracket_expression = 40, + RULE_indexer_argument = 41, RULE_predefined_type = 42, RULE_expression_list = 43, + RULE_object_or_collection_initializer = 44, RULE_object_initializer = 45, + RULE_member_initializer_list = 46, RULE_member_initializer = 47, RULE_initializer_value = 48, + RULE_collection_initializer = 49, RULE_element_initializer = 50, RULE_anonymous_object_initializer = 51, + RULE_member_declarator_list = 52, RULE_member_declarator = 53, RULE_unbound_type_name = 54, + RULE_generic_dimension_specifier = 55, RULE_isType = 56, RULE_isTypePatternArms = 57, + RULE_isTypePatternArm = 58, RULE_lambda_expression = 59, RULE_anonymous_function_signature = 60, + RULE_explicit_anonymous_function_parameter_list = 61, RULE_explicit_anonymous_function_parameter = 62, + RULE_implicit_anonymous_function_parameter_list = 63, RULE_anonymous_function_body = 64, + RULE_query_expression = 65, RULE_from_clause = 66, RULE_query_body = 67, + RULE_query_body_clause = 68, RULE_let_clause = 69, RULE_where_clause = 70, + RULE_combined_join_clause = 71, RULE_orderby_clause = 72, RULE_ordering = 73, + RULE_select_or_group_clause = 74, RULE_query_continuation = 75, RULE_statement = 76, + RULE_declarationStatement = 77, RULE_local_function_declaration = 78, + RULE_local_function_header = 79, RULE_local_function_modifiers = 80, RULE_local_function_body = 81, + RULE_labeled_Statement = 82, RULE_embedded_statement = 83, RULE_simple_embedded_statement = 84, + RULE_block = 85, RULE_local_variable_declaration = 86, RULE_local_variable_type = 87, + RULE_local_variable_declarator = 88, RULE_local_variable_initializer = 89, + RULE_local_constant_declaration = 90, RULE_if_body = 91, RULE_switch_section = 92, + RULE_switch_label = 93, RULE_case_guard = 94, RULE_statement_list = 95, + RULE_for_initializer = 96, RULE_for_iterator = 97, RULE_catch_clauses = 98, + RULE_specific_catch_clause = 99, RULE_general_catch_clause = 100, RULE_exception_filter = 101, + RULE_finally_clause = 102, RULE_resource_acquisition = 103, RULE_namespace_declaration = 104, + RULE_qualified_identifier = 105, RULE_namespace_body = 106, RULE_extern_alias_directives = 107, + RULE_extern_alias_directive = 108, RULE_using_directives = 109, RULE_using_directive = 110, + RULE_namespace_member_declarations = 111, RULE_namespace_member_declaration = 112, + RULE_type_declaration = 113, RULE_qualified_alias_member = 114, RULE_type_parameter_list = 115, + RULE_type_parameter = 116, RULE_class_base = 117, RULE_interface_type_list = 118, + RULE_type_parameter_constraints_clauses = 119, RULE_type_parameter_constraints_clause = 120, + RULE_type_parameter_constraints = 121, RULE_primary_constraint = 122, + RULE_secondary_constraints = 123, RULE_constructor_constraint = 124, RULE_class_body = 125, + RULE_class_member_declarations = 126, RULE_class_member_declaration = 127, + RULE_all_member_modifiers = 128, RULE_all_member_modifier = 129, RULE_common_member_declaration = 130, + RULE_typed_member_declaration = 131, RULE_constant_declarators = 132, + RULE_constant_declarator = 133, RULE_variable_declarators = 134, RULE_variable_declarator = 135, + RULE_variable_initializer = 136, RULE_return_type = 137, RULE_member_name = 138, + RULE_method_body = 139, RULE_formal_parameter_list = 140, RULE_fixed_parameters = 141, + RULE_fixed_parameter = 142, RULE_parameter_modifier = 143, RULE_parameter_array = 144, + RULE_accessor_declarations = 145, RULE_get_accessor_declaration = 146, + RULE_set_accessor_declaration = 147, RULE_accessor_modifier = 148, RULE_accessor_body = 149, + RULE_event_accessor_declarations = 150, RULE_add_accessor_declaration = 151, + RULE_remove_accessor_declaration = 152, RULE_overloadable_operator = 153, + RULE_conversion_operator_declarator = 154, RULE_constructor_initializer = 155, + RULE_body = 156, RULE_struct_interfaces = 157, RULE_struct_body = 158, + RULE_struct_member_declaration = 159, RULE_array_type = 160, RULE_rank_specifier = 161, + RULE_array_initializer = 162, RULE_variant_type_parameter_list = 163, + RULE_variant_type_parameter = 164, RULE_variance_annotation = 165, RULE_interface_base = 166, + RULE_interface_body = 167, RULE_interface_member_declaration = 168, RULE_interface_accessors = 169, + RULE_enum_base = 170, RULE_enum_body = 171, RULE_enum_member_declaration = 172, + RULE_global_attribute_section = 173, RULE_global_attribute_target = 174, + RULE_attributes = 175, RULE_attribute_section = 176, RULE_attribute_target = 177, + RULE_attribute_list = 178, RULE_attribute = 179, RULE_attribute_argument = 180, + RULE_pointer_type = 181, RULE_fixed_pointer_declarators = 182, RULE_fixed_pointer_declarator = 183, + RULE_fixed_pointer_initializer = 184, RULE_fixed_size_buffer_declarator = 185, + RULE_stackalloc_initializer = 186, RULE_right_arrow = 187, RULE_right_shift = 188, + RULE_right_shift_assignment = 189, RULE_literal = 190, RULE_boolean_literal = 191, + RULE_string_literal = 192, RULE_interpolated_regular_string = 193, RULE_interpolated_verbatium_string = 194, + RULE_interpolated_regular_string_part = 195, RULE_interpolated_verbatium_string_part = 196, + RULE_interpolated_string_expression = 197, RULE_keyword = 198, RULE_class_definition = 199, + RULE_struct_definition = 200, RULE_interface_definition = 201, RULE_enum_definition = 202, + RULE_delegate_definition = 203, RULE_event_declaration = 204, RULE_field_declaration = 205, + RULE_property_declaration = 206, RULE_constant_declaration = 207, RULE_indexer_declaration = 208, + RULE_destructor_definition = 209, RULE_constructor_declaration = 210, + RULE_method_declaration = 211, RULE_method_member_name = 212, RULE_operator_declaration = 213, + RULE_arg_declaration = 214, RULE_method_invocation = 215, RULE_object_creation_expression = 216, + RULE_identifier = 217; + private static String[] makeRuleNames() { + return new String[] { + "compilation_unit", "namespace_or_type_name", "type_", "base_type", "tuple_type", + "tuple_element", "simple_type", "numeric_type", "integral_type", "floating_point_type", + "class_type", "type_argument_list", "argument_list", "argument", "expression", + "non_assignment_expression", "assignment", "assignment_operator", "conditional_expression", + "null_coalescing_expression", "conditional_or_expression", "conditional_and_expression", + "inclusive_or_expression", "exclusive_or_expression", "and_expression", + "equality_expression", "relational_expression", "shift_expression", "additive_expression", + "multiplicative_expression", "switch_expression", "switch_expression_arms", + "switch_expression_arm", "range_expression", "unary_expression", "primary_expression", + "primary_expression_start", "throwable_expression", "throw_expression", + "member_access", "bracket_expression", "indexer_argument", "predefined_type", + "expression_list", "object_or_collection_initializer", "object_initializer", + "member_initializer_list", "member_initializer", "initializer_value", + "collection_initializer", "element_initializer", "anonymous_object_initializer", + "member_declarator_list", "member_declarator", "unbound_type_name", "generic_dimension_specifier", + "isType", "isTypePatternArms", "isTypePatternArm", "lambda_expression", + "anonymous_function_signature", "explicit_anonymous_function_parameter_list", + "explicit_anonymous_function_parameter", "implicit_anonymous_function_parameter_list", + "anonymous_function_body", "query_expression", "from_clause", "query_body", + "query_body_clause", "let_clause", "where_clause", "combined_join_clause", + "orderby_clause", "ordering", "select_or_group_clause", "query_continuation", + "statement", "declarationStatement", "local_function_declaration", "local_function_header", + "local_function_modifiers", "local_function_body", "labeled_Statement", + "embedded_statement", "simple_embedded_statement", "block", "local_variable_declaration", + "local_variable_type", "local_variable_declarator", "local_variable_initializer", + "local_constant_declaration", "if_body", "switch_section", "switch_label", + "case_guard", "statement_list", "for_initializer", "for_iterator", "catch_clauses", + "specific_catch_clause", "general_catch_clause", "exception_filter", + "finally_clause", "resource_acquisition", "namespace_declaration", "qualified_identifier", + "namespace_body", "extern_alias_directives", "extern_alias_directive", + "using_directives", "using_directive", "namespace_member_declarations", + "namespace_member_declaration", "type_declaration", "qualified_alias_member", + "type_parameter_list", "type_parameter", "class_base", "interface_type_list", + "type_parameter_constraints_clauses", "type_parameter_constraints_clause", + "type_parameter_constraints", "primary_constraint", "secondary_constraints", + "constructor_constraint", "class_body", "class_member_declarations", + "class_member_declaration", "all_member_modifiers", "all_member_modifier", + "common_member_declaration", "typed_member_declaration", "constant_declarators", + "constant_declarator", "variable_declarators", "variable_declarator", + "variable_initializer", "return_type", "member_name", "method_body", + "formal_parameter_list", "fixed_parameters", "fixed_parameter", "parameter_modifier", + "parameter_array", "accessor_declarations", "get_accessor_declaration", + "set_accessor_declaration", "accessor_modifier", "accessor_body", "event_accessor_declarations", + "add_accessor_declaration", "remove_accessor_declaration", "overloadable_operator", + "conversion_operator_declarator", "constructor_initializer", "body", + "struct_interfaces", "struct_body", "struct_member_declaration", "array_type", + "rank_specifier", "array_initializer", "variant_type_parameter_list", + "variant_type_parameter", "variance_annotation", "interface_base", "interface_body", + "interface_member_declaration", "interface_accessors", "enum_base", "enum_body", + "enum_member_declaration", "global_attribute_section", "global_attribute_target", + "attributes", "attribute_section", "attribute_target", "attribute_list", + "attribute", "attribute_argument", "pointer_type", "fixed_pointer_declarators", + "fixed_pointer_declarator", "fixed_pointer_initializer", "fixed_size_buffer_declarator", + "stackalloc_initializer", "right_arrow", "right_shift", "right_shift_assignment", + "literal", "boolean_literal", "string_literal", "interpolated_regular_string", + "interpolated_verbatium_string", "interpolated_regular_string_part", + "interpolated_verbatium_string_part", "interpolated_string_expression", + "keyword", "class_definition", "struct_definition", "interface_definition", + "enum_definition", "delegate_definition", "event_declaration", "field_declaration", + "property_declaration", "constant_declaration", "indexer_declaration", + "destructor_definition", "constructor_declaration", "method_declaration", + "method_member_name", "operator_declaration", "arg_declaration", "method_invocation", + "object_creation_expression", "identifier" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "'\u00EF\u00BB\u00BF'", null, "'/***/'", null, null, null, null, + "'#'", "'abstract'", "'add'", "'alias'", "'__arglist'", "'as'", "'ascending'", + "'async'", "'await'", "'base'", "'bool'", "'break'", "'by'", "'byte'", + "'case'", "'catch'", "'char'", "'checked'", "'class'", "'const'", "'continue'", + "'decimal'", "'default'", "'delegate'", "'descending'", "'do'", "'double'", + "'dynamic'", "'else'", "'enum'", "'equals'", "'event'", "'explicit'", + "'extern'", "'false'", "'finally'", "'fixed'", "'float'", "'for'", "'foreach'", + "'from'", "'get'", "'goto'", "'group'", "'if'", "'implicit'", "'in'", + "'int'", "'interface'", "'internal'", "'into'", "'is'", "'join'", "'let'", + "'lock'", "'long'", "'nameof'", "'namespace'", "'new'", "'null'", "'object'", + "'on'", "'operator'", "'orderby'", "'out'", "'override'", "'params'", + "'partial'", "'private'", "'protected'", "'public'", "'readonly'", "'ref'", + "'remove'", "'return'", "'sbyte'", "'sealed'", "'select'", "'set'", "'short'", + "'sizeof'", "'stackalloc'", "'static'", "'string'", "'struct'", "'switch'", + "'this'", "'throw'", "'true'", "'try'", "'typeof'", "'uint'", "'ulong'", + "'unchecked'", "'unmanaged'", "'unsafe'", "'ushort'", "'using'", "'var'", + "'virtual'", "'void'", "'volatile'", "'when'", "'where'", "'while'", + "'yield'", null, null, null, null, null, null, null, null, null, null, + null, "'{'", "'}'", "'['", "']'", "'('", "')'", "'.'", "','", "':'", + "';'", "'+'", "'-'", "'*'", "'/'", "'%'", "'&'", "'|'", "'^'", "'!'", + "'~'", "'='", "'<'", "'>'", "'?'", "'::'", "'??'", "'++'", "'--'", "'&&'", + "'||'", "'->'", "'=='", "'!='", "'<='", "'>='", "'+='", "'-='", "'*='", + "'/='", "'%='", "'&='", "'|='", "'^='", "'<<'", "'<<='", "'??='", "'..'", + "'{{'", null, null, null, null, null, null, null, null, null, null, "'define'", + "'undef'", "'elif'", "'endif'", "'line'", null, null, null, null, null, + null, "'hidden'", null, null, null, "'}}'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT", "EMPTY_DELIMITED_DOC_COMMENT", + "DELIMITED_DOC_COMMENT", "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", + "WHITESPACES", "SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS", + "ASCENDING", "ASYNC", "AWAIT", "BASE", "BOOL", "BREAK", "BY", "BYTE", + "CASE", "CATCH", "CHAR", "CHECKED", "CLASS", "CONST", "CONTINUE", "DECIMAL", + "DEFAULT", "DELEGATE", "DESCENDING", "DO", "DOUBLE", "DYNAMIC", "ELSE", + "ENUM", "EQUALS", "EVENT", "EXPLICIT", "EXTERN", "FALSE", "FINALLY", + "FIXED", "FLOAT", "FOR", "FOREACH", "FROM", "GET", "GOTO", "GROUP", "IF", + "IMPLICIT", "IN", "INT", "INTERFACE", "INTERNAL", "INTO", "IS", "JOIN", + "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE", "NEW", "NULL_", "OBJECT", + "ON", "OPERATOR", "ORDERBY", "OUT", "OVERRIDE", "PARAMS", "PARTIAL", + "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", "REF", "REMOVE", "RETURN", + "SBYTE", "SEALED", "SELECT", "SET", "SHORT", "SIZEOF", "STACKALLOC", + "STATIC", "STRING", "STRUCT", "SWITCH", "THIS", "THROW", "TRUE", "TRY", + "TYPEOF", "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE", "USHORT", + "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE", "WHEN", "WHERE", "WHILE", + "YIELD", "IDENTIFIER", "LITERAL_ACCESS", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", + "BIN_INTEGER_LITERAL", "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING", + "VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START", "INTERPOLATED_VERBATIUM_STRING_START", + "OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS", + "CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON", "PLUS", "MINUS", + "STAR", "DIV", "PERCENT", "AMP", "BITWISE_OR", "CARET", "BANG", "TILDE", + "ASSIGNMENT", "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING", + "OP_INC", "OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ", "OP_NE", "OP_LE", + "OP_GE", "OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT", "OP_MULT_ASSIGNMENT", + "OP_DIV_ASSIGNMENT", "OP_MOD_ASSIGNMENT", "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", + "OP_XOR_ASSIGNMENT", "OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT", + "OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE", "REGULAR_CHAR_INSIDE", + "VERBATIUM_DOUBLE_QUOTE_INSIDE", "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", + "VERBATIUM_INSIDE_STRING", "CLOSE_BRACE_INSIDE", "FORMAT_STRING", "DIRECTIVE_WHITESPACES", + "DIGITS", "DEFINE", "UNDEF", "ELIF", "ENDIF", "LINE", "ERROR", "WARNING", + "REGION", "ENDREGION", "PRAGMA", "NULLABLE", "DIRECTIVE_HIDDEN", "CONDITIONAL_SYMBOL", + "DIRECTIVE_NEW_LINE", "TEXT", "DOUBLE_CURLY_CLOSE_INSIDE" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + 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] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "CSharpParser.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public CSharpParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + public static class Compilation_unitContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(CSharpParser.EOF, 0); } + public TerminalNode BYTE_ORDER_MARK() { return getToken(CSharpParser.BYTE_ORDER_MARK, 0); } + public Extern_alias_directivesContext extern_alias_directives() { + return getRuleContext(Extern_alias_directivesContext.class,0); + } + public Using_directivesContext using_directives() { + return getRuleContext(Using_directivesContext.class,0); + } + public List global_attribute_section() { + return getRuleContexts(Global_attribute_sectionContext.class); + } + public Global_attribute_sectionContext global_attribute_section(int i) { + return getRuleContext(Global_attribute_sectionContext.class,i); + } + public Namespace_member_declarationsContext namespace_member_declarations() { + return getRuleContext(Namespace_member_declarationsContext.class,0); + } + public Compilation_unitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_compilation_unit; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterCompilation_unit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitCompilation_unit(this); + } + } + + public final Compilation_unitContext compilation_unit() throws RecognitionException { + Compilation_unitContext _localctx = new Compilation_unitContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_compilation_unit); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(437); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==BYTE_ORDER_MARK) { + { + setState(436); + match(BYTE_ORDER_MARK); + } + } + + setState(440); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) { + case 1: + { + setState(439); + extern_alias_directives(); + } + break; + } + setState(443); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(442); + using_directives(); + } + } + + setState(448); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,3,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(445); + global_attribute_section(); + } + } + } + setState(450); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,3,_ctx); + } + setState(452); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASYNC) | (1L << CLASS) | (1L << DELEGATE) | (1L << ENUM) | (1L << EXTERN) | (1L << INTERFACE) | (1L << INTERNAL))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (NAMESPACE - 65)) | (1L << (NEW - 65)) | (1L << (OVERRIDE - 65)) | (1L << (PARTIAL - 65)) | (1L << (PRIVATE - 65)) | (1L << (PROTECTED - 65)) | (1L << (PUBLIC - 65)) | (1L << (READONLY - 65)) | (1L << (REF - 65)) | (1L << (SEALED - 65)) | (1L << (STATIC - 65)) | (1L << (STRUCT - 65)) | (1L << (UNSAFE - 65)) | (1L << (VIRTUAL - 65)) | (1L << (VOLATILE - 65)) | (1L << (OPEN_BRACKET - 65)))) != 0)) { + { + setState(451); + namespace_member_declarations(); + } + } + + setState(454); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Namespace_or_type_nameContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public Qualified_alias_memberContext qualified_alias_member() { + return getRuleContext(Qualified_alias_memberContext.class,0); + } + public List DOT() { return getTokens(CSharpParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(CSharpParser.DOT, i); + } + public List type_argument_list() { + return getRuleContexts(Type_argument_listContext.class); + } + public Type_argument_listContext type_argument_list(int i) { + return getRuleContext(Type_argument_listContext.class,i); + } + public Namespace_or_type_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespace_or_type_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterNamespace_or_type_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitNamespace_or_type_name(this); + } + } + + public final Namespace_or_type_nameContext namespace_or_type_name() throws RecognitionException { + Namespace_or_type_nameContext _localctx = new Namespace_or_type_nameContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_namespace_or_type_name); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(461); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) { + case 1: + { + setState(456); + identifier(); + setState(458); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { + case 1: + { + setState(457); + type_argument_list(); + } + break; + } + } + break; + case 2: + { + setState(460); + qualified_alias_member(); + } + break; + } + setState(470); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,8,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(463); + match(DOT); + setState(464); + identifier(); + setState(466); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) { + case 1: + { + setState(465); + type_argument_list(); + } + break; + } + } + } + } + setState(472); + _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 Type_Context extends ParserRuleContext { + public Base_typeContext base_type() { + return getRuleContext(Base_typeContext.class,0); + } + public List INTERR() { return getTokens(CSharpParser.INTERR); } + public TerminalNode INTERR(int i) { + return getToken(CSharpParser.INTERR, i); + } + public List rank_specifier() { + return getRuleContexts(Rank_specifierContext.class); + } + public Rank_specifierContext rank_specifier(int i) { + return getRuleContext(Rank_specifierContext.class,i); + } + public List STAR() { return getTokens(CSharpParser.STAR); } + public TerminalNode STAR(int i) { + return getToken(CSharpParser.STAR, i); + } + public Type_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterType_(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitType_(this); + } + } + + public final Type_Context type_() throws RecognitionException { + Type_Context _localctx = new Type_Context(_ctx, getState()); + enterRule(_localctx, 4, RULE_type_); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(473); + base_type(); + setState(479); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,10,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(477); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INTERR: + { + setState(474); + match(INTERR); + } + break; + case OPEN_BRACKET: + { + setState(475); + rank_specifier(); + } + break; + case STAR: + { + setState(476); + match(STAR); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(481); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,10,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Base_typeContext extends ParserRuleContext { + public Simple_typeContext simple_type() { + return getRuleContext(Simple_typeContext.class,0); + } + public Class_typeContext class_type() { + return getRuleContext(Class_typeContext.class,0); + } + public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } + public TerminalNode STAR() { return getToken(CSharpParser.STAR, 0); } + public Tuple_typeContext tuple_type() { + return getRuleContext(Tuple_typeContext.class,0); + } + public Base_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_base_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterBase_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitBase_type(this); + } + } + + public final Base_typeContext base_type() throws RecognitionException { + Base_typeContext _localctx = new Base_typeContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_base_type); + try { + setState(487); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BOOL: + case BYTE: + case CHAR: + case DECIMAL: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SBYTE: + case SHORT: + case UINT: + case ULONG: + case USHORT: + enterOuterAlt(_localctx, 1); + { + setState(482); + simple_type(); + } + break; + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BY: + case DESCENDING: + case DYNAMIC: + case EQUALS: + case FROM: + case GET: + case GROUP: + case INTO: + case JOIN: + case LET: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SELECT: + case SET: + case STRING: + case UNMANAGED: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(483); + class_type(); + } + break; + case VOID: + enterOuterAlt(_localctx, 3); + { + setState(484); + match(VOID); + setState(485); + match(STAR); + } + break; + case OPEN_PARENS: + enterOuterAlt(_localctx, 4); + { + setState(486); + tuple_type(); + } + 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 Tuple_typeContext extends ParserRuleContext { + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public List tuple_element() { + return getRuleContexts(Tuple_elementContext.class); + } + public Tuple_elementContext tuple_element(int i) { + return getRuleContext(Tuple_elementContext.class,i); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Tuple_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tuple_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterTuple_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitTuple_type(this); + } + } + + public final Tuple_typeContext tuple_type() throws RecognitionException { + Tuple_typeContext _localctx = new Tuple_typeContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_tuple_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(489); + match(OPEN_PARENS); + setState(490); + tuple_element(); + setState(493); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(491); + match(COMMA); + setState(492); + tuple_element(); + } + } + setState(495); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==COMMA ); + setState(497); + match(CLOSE_PARENS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Tuple_elementContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Tuple_elementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tuple_element; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterTuple_element(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitTuple_element(this); + } + } + + public final Tuple_elementContext tuple_element() throws RecognitionException { + Tuple_elementContext _localctx = new Tuple_elementContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_tuple_element); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(499); + type_(); + setState(501); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)))) != 0)) { + { + setState(500); + identifier(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Simple_typeContext extends ParserRuleContext { + public Numeric_typeContext numeric_type() { + return getRuleContext(Numeric_typeContext.class,0); + } + public TerminalNode BOOL() { return getToken(CSharpParser.BOOL, 0); } + public Simple_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simple_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSimple_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSimple_type(this); + } + } + + public final Simple_typeContext simple_type() throws RecognitionException { + Simple_typeContext _localctx = new Simple_typeContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_simple_type); + try { + setState(505); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BYTE: + case CHAR: + case DECIMAL: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SBYTE: + case SHORT: + case UINT: + case ULONG: + case USHORT: + enterOuterAlt(_localctx, 1); + { + setState(503); + numeric_type(); + } + break; + case BOOL: + enterOuterAlt(_localctx, 2); + { + setState(504); + match(BOOL); + } + 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 Numeric_typeContext extends ParserRuleContext { + public Integral_typeContext integral_type() { + return getRuleContext(Integral_typeContext.class,0); + } + public Floating_point_typeContext floating_point_type() { + return getRuleContext(Floating_point_typeContext.class,0); + } + public TerminalNode DECIMAL() { return getToken(CSharpParser.DECIMAL, 0); } + public Numeric_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_numeric_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterNumeric_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitNumeric_type(this); + } + } + + public final Numeric_typeContext numeric_type() throws RecognitionException { + Numeric_typeContext _localctx = new Numeric_typeContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_numeric_type); + try { + setState(510); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BYTE: + case CHAR: + case INT: + case LONG: + case SBYTE: + case SHORT: + case UINT: + case ULONG: + case USHORT: + enterOuterAlt(_localctx, 1); + { + setState(507); + integral_type(); + } + break; + case DOUBLE: + case FLOAT: + enterOuterAlt(_localctx, 2); + { + setState(508); + floating_point_type(); + } + break; + case DECIMAL: + enterOuterAlt(_localctx, 3); + { + setState(509); + match(DECIMAL); + } + 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 Integral_typeContext extends ParserRuleContext { + public TerminalNode SBYTE() { return getToken(CSharpParser.SBYTE, 0); } + public TerminalNode BYTE() { return getToken(CSharpParser.BYTE, 0); } + public TerminalNode SHORT() { return getToken(CSharpParser.SHORT, 0); } + public TerminalNode USHORT() { return getToken(CSharpParser.USHORT, 0); } + public TerminalNode INT() { return getToken(CSharpParser.INT, 0); } + public TerminalNode UINT() { return getToken(CSharpParser.UINT, 0); } + public TerminalNode LONG() { return getToken(CSharpParser.LONG, 0); } + public TerminalNode ULONG() { return getToken(CSharpParser.ULONG, 0); } + public TerminalNode CHAR() { return getToken(CSharpParser.CHAR, 0); } + public Integral_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_integral_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterIntegral_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitIntegral_type(this); + } + } + + public final Integral_typeContext integral_type() throws RecognitionException { + Integral_typeContext _localctx = new Integral_typeContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_integral_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(512); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << CHAR) | (1L << INT) | (1L << LONG))) != 0) || ((((_la - 83)) & ~0x3f) == 0 && ((1L << (_la - 83)) & ((1L << (SBYTE - 83)) | (1L << (SHORT - 83)) | (1L << (UINT - 83)) | (1L << (ULONG - 83)) | (1L << (USHORT - 83)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Floating_point_typeContext extends ParserRuleContext { + public TerminalNode FLOAT() { return getToken(CSharpParser.FLOAT, 0); } + public TerminalNode DOUBLE() { return getToken(CSharpParser.DOUBLE, 0); } + public Floating_point_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_floating_point_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFloating_point_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFloating_point_type(this); + } + } + + public final Floating_point_typeContext floating_point_type() throws RecognitionException { + Floating_point_typeContext _localctx = new Floating_point_typeContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_floating_point_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(514); + _la = _input.LA(1); + if ( !(_la==DOUBLE || _la==FLOAT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Class_typeContext extends ParserRuleContext { + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class,0); + } + public TerminalNode OBJECT() { return getToken(CSharpParser.OBJECT, 0); } + public TerminalNode DYNAMIC() { return getToken(CSharpParser.DYNAMIC, 0); } + public TerminalNode STRING() { return getToken(CSharpParser.STRING, 0); } + public Class_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_class_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterClass_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitClass_type(this); + } + } + + public final Class_typeContext class_type() throws RecognitionException { + Class_typeContext _localctx = new Class_typeContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_class_type); + try { + setState(520); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(516); + namespace_or_type_name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(517); + match(OBJECT); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(518); + match(DYNAMIC); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(519); + match(STRING); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Type_argument_listContext extends ParserRuleContext { + public TerminalNode LT() { return getToken(CSharpParser.LT, 0); } + public List type_() { + return getRuleContexts(Type_Context.class); + } + public Type_Context type_(int i) { + return getRuleContext(Type_Context.class,i); + } + public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Type_argument_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_argument_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterType_argument_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitType_argument_list(this); + } + } + + public final Type_argument_listContext type_argument_list() throws RecognitionException { + Type_argument_listContext _localctx = new Type_argument_listContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_type_argument_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(522); + match(LT); + setState(523); + type_(); + setState(528); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(524); + match(COMMA); + setState(525); + type_(); + } + } + setState(530); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(531); + match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Argument_listContext extends ParserRuleContext { + public List argument() { + return getRuleContexts(ArgumentContext.class); + } + public ArgumentContext argument(int i) { + return getRuleContext(ArgumentContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Argument_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_argument_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterArgument_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitArgument_list(this); + } + } + + public final Argument_listContext argument_list() throws RecognitionException { + Argument_listContext _localctx = new Argument_listContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_argument_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(533); + argument(); + setState(538); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(534); + match(COMMA); + setState(535); + argument(); + } + } + setState(540); + _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 ArgumentContext extends ParserRuleContext { + public Token refout; + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public TerminalNode VAR() { return getToken(CSharpParser.VAR, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } + public TerminalNode OUT() { return getToken(CSharpParser.OUT, 0); } + public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } + public ArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_argument; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterArgument(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitArgument(this); + } + } + + public final ArgumentContext argument() throws RecognitionException { + ArgumentContext _localctx = new ArgumentContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_argument); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(544); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) { + case 1: + { + setState(541); + identifier(); + setState(542); + match(COLON); + } + break; + } + setState(547); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { + case 1: + { + setState(546); + ((ArgumentContext)_localctx).refout = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & ((1L << (IN - 54)) | (1L << (OUT - 54)) | (1L << (REF - 54)))) != 0)) ) { + ((ArgumentContext)_localctx).refout = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + setState(551); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) { + case 1: + { + setState(549); + match(VAR); + } + break; + case 2: + { + setState(550); + type_(); + } + break; + } + setState(553); + 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 AssignmentContext assignment() { + return getRuleContext(AssignmentContext.class,0); + } + public Non_assignment_expressionContext non_assignment_expression() { + return getRuleContext(Non_assignment_expressionContext.class,0); + } + public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitExpression(this); + } + } + + public final ExpressionContext expression() throws RecognitionException { + ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_expression); + try { + setState(559); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(555); + assignment(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(556); + non_assignment_expression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(557); + match(REF); + setState(558); + non_assignment_expression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Non_assignment_expressionContext extends ParserRuleContext { + public Lambda_expressionContext lambda_expression() { + return getRuleContext(Lambda_expressionContext.class,0); + } + public Query_expressionContext query_expression() { + return getRuleContext(Query_expressionContext.class,0); + } + public Conditional_expressionContext conditional_expression() { + return getRuleContext(Conditional_expressionContext.class,0); + } + public Non_assignment_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_non_assignment_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterNon_assignment_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitNon_assignment_expression(this); + } + } + + public final Non_assignment_expressionContext non_assignment_expression() throws RecognitionException { + Non_assignment_expressionContext _localctx = new Non_assignment_expressionContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_non_assignment_expression); + try { + setState(564); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(561); + lambda_expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(562); + query_expression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(563); + conditional_expression(); + } + 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 Unary_expressionContext unary_expression() { + return getRuleContext(Unary_expressionContext.class,0); + } + public Assignment_operatorContext assignment_operator() { + return getRuleContext(Assignment_operatorContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode OP_COALESCING_ASSIGNMENT() { return getToken(CSharpParser.OP_COALESCING_ASSIGNMENT, 0); } + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class,0); + } + public AssignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignment; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAssignment(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAssignment(this); + } + } + + public final AssignmentContext assignment() throws RecognitionException { + AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_assignment); + try { + setState(574); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(566); + unary_expression(); + setState(567); + assignment_operator(); + setState(568); + expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(570); + unary_expression(); + setState(571); + match(OP_COALESCING_ASSIGNMENT); + setState(572); + throwable_expression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Assignment_operatorContext extends ParserRuleContext { + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public TerminalNode OP_ADD_ASSIGNMENT() { return getToken(CSharpParser.OP_ADD_ASSIGNMENT, 0); } + public TerminalNode OP_SUB_ASSIGNMENT() { return getToken(CSharpParser.OP_SUB_ASSIGNMENT, 0); } + public TerminalNode OP_MULT_ASSIGNMENT() { return getToken(CSharpParser.OP_MULT_ASSIGNMENT, 0); } + public TerminalNode OP_DIV_ASSIGNMENT() { return getToken(CSharpParser.OP_DIV_ASSIGNMENT, 0); } + public TerminalNode OP_MOD_ASSIGNMENT() { return getToken(CSharpParser.OP_MOD_ASSIGNMENT, 0); } + public TerminalNode OP_AND_ASSIGNMENT() { return getToken(CSharpParser.OP_AND_ASSIGNMENT, 0); } + public TerminalNode OP_OR_ASSIGNMENT() { return getToken(CSharpParser.OP_OR_ASSIGNMENT, 0); } + public TerminalNode OP_XOR_ASSIGNMENT() { return getToken(CSharpParser.OP_XOR_ASSIGNMENT, 0); } + public TerminalNode OP_LEFT_SHIFT_ASSIGNMENT() { return getToken(CSharpParser.OP_LEFT_SHIFT_ASSIGNMENT, 0); } + public Right_shift_assignmentContext right_shift_assignment() { + return getRuleContext(Right_shift_assignmentContext.class,0); + } + public Assignment_operatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignment_operator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAssignment_operator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAssignment_operator(this); + } + } + + public final Assignment_operatorContext assignment_operator() throws RecognitionException { + Assignment_operatorContext _localctx = new Assignment_operatorContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_assignment_operator); + try { + setState(587); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ASSIGNMENT: + enterOuterAlt(_localctx, 1); + { + setState(576); + match(ASSIGNMENT); + } + break; + case OP_ADD_ASSIGNMENT: + enterOuterAlt(_localctx, 2); + { + setState(577); + match(OP_ADD_ASSIGNMENT); + } + break; + case OP_SUB_ASSIGNMENT: + enterOuterAlt(_localctx, 3); + { + setState(578); + match(OP_SUB_ASSIGNMENT); + } + break; + case OP_MULT_ASSIGNMENT: + enterOuterAlt(_localctx, 4); + { + setState(579); + match(OP_MULT_ASSIGNMENT); + } + break; + case OP_DIV_ASSIGNMENT: + enterOuterAlt(_localctx, 5); + { + setState(580); + match(OP_DIV_ASSIGNMENT); + } + break; + case OP_MOD_ASSIGNMENT: + enterOuterAlt(_localctx, 6); + { + setState(581); + match(OP_MOD_ASSIGNMENT); + } + break; + case OP_AND_ASSIGNMENT: + enterOuterAlt(_localctx, 7); + { + setState(582); + match(OP_AND_ASSIGNMENT); + } + break; + case OP_OR_ASSIGNMENT: + enterOuterAlt(_localctx, 8); + { + setState(583); + match(OP_OR_ASSIGNMENT); + } + break; + case OP_XOR_ASSIGNMENT: + enterOuterAlt(_localctx, 9); + { + setState(584); + match(OP_XOR_ASSIGNMENT); + } + break; + case OP_LEFT_SHIFT_ASSIGNMENT: + enterOuterAlt(_localctx, 10); + { + setState(585); + match(OP_LEFT_SHIFT_ASSIGNMENT); + } + break; + case GT: + enterOuterAlt(_localctx, 11); + { + setState(586); + right_shift_assignment(); + } + 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 Conditional_expressionContext extends ParserRuleContext { + public Null_coalescing_expressionContext null_coalescing_expression() { + return getRuleContext(Null_coalescing_expressionContext.class,0); + } + public TerminalNode INTERR() { return getToken(CSharpParser.INTERR, 0); } + public List throwable_expression() { + return getRuleContexts(Throwable_expressionContext.class); + } + public Throwable_expressionContext throwable_expression(int i) { + return getRuleContext(Throwable_expressionContext.class,i); + } + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public Conditional_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conditional_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterConditional_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitConditional_expression(this); + } + } + + public final Conditional_expressionContext conditional_expression() throws RecognitionException { + Conditional_expressionContext _localctx = new Conditional_expressionContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_conditional_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(589); + null_coalescing_expression(); + setState(595); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) { + case 1: + { + setState(590); + match(INTERR); + setState(591); + throwable_expression(); + setState(592); + match(COLON); + setState(593); + throwable_expression(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Null_coalescing_expressionContext extends ParserRuleContext { + public Conditional_or_expressionContext conditional_or_expression() { + return getRuleContext(Conditional_or_expressionContext.class,0); + } + public TerminalNode OP_COALESCING() { return getToken(CSharpParser.OP_COALESCING, 0); } + public Null_coalescing_expressionContext null_coalescing_expression() { + return getRuleContext(Null_coalescing_expressionContext.class,0); + } + public Throw_expressionContext throw_expression() { + return getRuleContext(Throw_expressionContext.class,0); + } + public Null_coalescing_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_null_coalescing_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterNull_coalescing_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitNull_coalescing_expression(this); + } + } + + public final Null_coalescing_expressionContext null_coalescing_expression() throws RecognitionException { + Null_coalescing_expressionContext _localctx = new Null_coalescing_expressionContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_null_coalescing_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(597); + conditional_or_expression(); + setState(603); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OP_COALESCING) { + { + setState(598); + match(OP_COALESCING); + setState(601); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + { + setState(599); + null_coalescing_expression(); + } + break; + case THROW: + { + setState(600); + throw_expression(); + } + 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 Conditional_or_expressionContext extends ParserRuleContext { + public List conditional_and_expression() { + return getRuleContexts(Conditional_and_expressionContext.class); + } + public Conditional_and_expressionContext conditional_and_expression(int i) { + return getRuleContext(Conditional_and_expressionContext.class,i); + } + public List OP_OR() { return getTokens(CSharpParser.OP_OR); } + public TerminalNode OP_OR(int i) { + return getToken(CSharpParser.OP_OR, i); + } + public Conditional_or_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conditional_or_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterConditional_or_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitConditional_or_expression(this); + } + } + + public final Conditional_or_expressionContext conditional_or_expression() throws RecognitionException { + Conditional_or_expressionContext _localctx = new Conditional_or_expressionContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_conditional_or_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(605); + conditional_and_expression(); + setState(610); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==OP_OR) { + { + { + setState(606); + match(OP_OR); + setState(607); + conditional_and_expression(); + } + } + setState(612); + _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 Conditional_and_expressionContext extends ParserRuleContext { + public List inclusive_or_expression() { + return getRuleContexts(Inclusive_or_expressionContext.class); + } + public Inclusive_or_expressionContext inclusive_or_expression(int i) { + return getRuleContext(Inclusive_or_expressionContext.class,i); + } + public List OP_AND() { return getTokens(CSharpParser.OP_AND); } + public TerminalNode OP_AND(int i) { + return getToken(CSharpParser.OP_AND, i); + } + public Conditional_and_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conditional_and_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterConditional_and_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitConditional_and_expression(this); + } + } + + public final Conditional_and_expressionContext conditional_and_expression() throws RecognitionException { + Conditional_and_expressionContext _localctx = new Conditional_and_expressionContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_conditional_and_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(613); + inclusive_or_expression(); + setState(618); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==OP_AND) { + { + { + setState(614); + match(OP_AND); + setState(615); + inclusive_or_expression(); + } + } + setState(620); + _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 Inclusive_or_expressionContext extends ParserRuleContext { + public List exclusive_or_expression() { + return getRuleContexts(Exclusive_or_expressionContext.class); + } + public Exclusive_or_expressionContext exclusive_or_expression(int i) { + return getRuleContext(Exclusive_or_expressionContext.class,i); + } + public List BITWISE_OR() { return getTokens(CSharpParser.BITWISE_OR); } + public TerminalNode BITWISE_OR(int i) { + return getToken(CSharpParser.BITWISE_OR, i); + } + public Inclusive_or_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_inclusive_or_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInclusive_or_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInclusive_or_expression(this); + } + } + + public final Inclusive_or_expressionContext inclusive_or_expression() throws RecognitionException { + Inclusive_or_expressionContext _localctx = new Inclusive_or_expressionContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_inclusive_or_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(621); + exclusive_or_expression(); + setState(626); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITWISE_OR) { + { + { + setState(622); + match(BITWISE_OR); + setState(623); + exclusive_or_expression(); + } + } + setState(628); + _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 Exclusive_or_expressionContext extends ParserRuleContext { + public List and_expression() { + return getRuleContexts(And_expressionContext.class); + } + public And_expressionContext and_expression(int i) { + return getRuleContext(And_expressionContext.class,i); + } + public List CARET() { return getTokens(CSharpParser.CARET); } + public TerminalNode CARET(int i) { + return getToken(CSharpParser.CARET, i); + } + public Exclusive_or_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exclusive_or_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterExclusive_or_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitExclusive_or_expression(this); + } + } + + public final Exclusive_or_expressionContext exclusive_or_expression() throws RecognitionException { + Exclusive_or_expressionContext _localctx = new Exclusive_or_expressionContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_exclusive_or_expression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(629); + and_expression(); + setState(634); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,32,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(630); + match(CARET); + setState(631); + and_expression(); + } + } + } + setState(636); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,32,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class And_expressionContext extends ParserRuleContext { + public List equality_expression() { + return getRuleContexts(Equality_expressionContext.class); + } + public Equality_expressionContext equality_expression(int i) { + return getRuleContext(Equality_expressionContext.class,i); + } + public List AMP() { return getTokens(CSharpParser.AMP); } + public TerminalNode AMP(int i) { + return getToken(CSharpParser.AMP, i); + } + public And_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_and_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAnd_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAnd_expression(this); + } + } + + public final And_expressionContext and_expression() throws RecognitionException { + And_expressionContext _localctx = new And_expressionContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_and_expression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(637); + equality_expression(); + setState(642); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,33,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(638); + match(AMP); + setState(639); + equality_expression(); + } + } + } + setState(644); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,33,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Equality_expressionContext extends ParserRuleContext { + public List relational_expression() { + return getRuleContexts(Relational_expressionContext.class); + } + public Relational_expressionContext relational_expression(int i) { + return getRuleContext(Relational_expressionContext.class,i); + } + public List OP_EQ() { return getTokens(CSharpParser.OP_EQ); } + public TerminalNode OP_EQ(int i) { + return getToken(CSharpParser.OP_EQ, i); + } + public List OP_NE() { return getTokens(CSharpParser.OP_NE); } + public TerminalNode OP_NE(int i) { + return getToken(CSharpParser.OP_NE, i); + } + public Equality_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_equality_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterEquality_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitEquality_expression(this); + } + } + + public final Equality_expressionContext equality_expression() throws RecognitionException { + Equality_expressionContext _localctx = new Equality_expressionContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_equality_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(645); + relational_expression(); + setState(650); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==OP_EQ || _la==OP_NE) { + { + { + setState(646); + _la = _input.LA(1); + if ( !(_la==OP_EQ || _la==OP_NE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(647); + relational_expression(); + } + } + setState(652); + _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 Relational_expressionContext extends ParserRuleContext { + public List shift_expression() { + return getRuleContexts(Shift_expressionContext.class); + } + public Shift_expressionContext shift_expression(int i) { + return getRuleContext(Shift_expressionContext.class,i); + } + public List IS() { return getTokens(CSharpParser.IS); } + public TerminalNode IS(int i) { + return getToken(CSharpParser.IS, i); + } + public List isType() { + return getRuleContexts(IsTypeContext.class); + } + public IsTypeContext isType(int i) { + return getRuleContext(IsTypeContext.class,i); + } + public List AS() { return getTokens(CSharpParser.AS); } + public TerminalNode AS(int i) { + return getToken(CSharpParser.AS, i); + } + public List type_() { + return getRuleContexts(Type_Context.class); + } + public Type_Context type_(int i) { + return getRuleContext(Type_Context.class,i); + } + public List LT() { return getTokens(CSharpParser.LT); } + public TerminalNode LT(int i) { + return getToken(CSharpParser.LT, i); + } + public List GT() { return getTokens(CSharpParser.GT); } + public TerminalNode GT(int i) { + return getToken(CSharpParser.GT, i); + } + public List OP_LE() { return getTokens(CSharpParser.OP_LE); } + public TerminalNode OP_LE(int i) { + return getToken(CSharpParser.OP_LE, i); + } + public List OP_GE() { return getTokens(CSharpParser.OP_GE); } + public TerminalNode OP_GE(int i) { + return getToken(CSharpParser.OP_GE, i); + } + public Relational_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_relational_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterRelational_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitRelational_expression(this); + } + } + + public final Relational_expressionContext relational_expression() throws RecognitionException { + Relational_expressionContext _localctx = new Relational_expressionContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_relational_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(653); + shift_expression(); + setState(662); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AS || _la==IS || ((((_la - 146)) & ~0x3f) == 0 && ((1L << (_la - 146)) & ((1L << (LT - 146)) | (1L << (GT - 146)) | (1L << (OP_LE - 146)) | (1L << (OP_GE - 146)))) != 0)) { + { + setState(660); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LT: + case GT: + case OP_LE: + case OP_GE: + { + setState(654); + _la = _input.LA(1); + if ( !(((((_la - 146)) & ~0x3f) == 0 && ((1L << (_la - 146)) & ((1L << (LT - 146)) | (1L << (GT - 146)) | (1L << (OP_LE - 146)) | (1L << (OP_GE - 146)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(655); + shift_expression(); + } + break; + case IS: + { + setState(656); + match(IS); + setState(657); + isType(); + } + break; + case AS: + { + setState(658); + match(AS); + setState(659); + type_(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(664); + _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 Shift_expressionContext extends ParserRuleContext { + public List additive_expression() { + return getRuleContexts(Additive_expressionContext.class); + } + public Additive_expressionContext additive_expression(int i) { + return getRuleContext(Additive_expressionContext.class,i); + } + public List OP_LEFT_SHIFT() { return getTokens(CSharpParser.OP_LEFT_SHIFT); } + public TerminalNode OP_LEFT_SHIFT(int i) { + return getToken(CSharpParser.OP_LEFT_SHIFT, i); + } + public List right_shift() { + return getRuleContexts(Right_shiftContext.class); + } + public Right_shiftContext right_shift(int i) { + return getRuleContext(Right_shiftContext.class,i); + } + public Shift_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_shift_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterShift_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitShift_expression(this); + } + } + + public final Shift_expressionContext shift_expression() throws RecognitionException { + Shift_expressionContext _localctx = new Shift_expressionContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_shift_expression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(665); + additive_expression(); + setState(673); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,38,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(668); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OP_LEFT_SHIFT: + { + setState(666); + match(OP_LEFT_SHIFT); + } + break; + case GT: + { + setState(667); + right_shift(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(670); + additive_expression(); + } + } + } + setState(675); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,38,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Additive_expressionContext extends ParserRuleContext { + public List multiplicative_expression() { + return getRuleContexts(Multiplicative_expressionContext.class); + } + public Multiplicative_expressionContext multiplicative_expression(int i) { + return getRuleContext(Multiplicative_expressionContext.class,i); + } + public List PLUS() { return getTokens(CSharpParser.PLUS); } + public TerminalNode PLUS(int i) { + return getToken(CSharpParser.PLUS, i); + } + public List MINUS() { return getTokens(CSharpParser.MINUS); } + public TerminalNode MINUS(int i) { + return getToken(CSharpParser.MINUS, i); + } + public Additive_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_additive_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAdditive_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAdditive_expression(this); + } + } + + public final Additive_expressionContext additive_expression() throws RecognitionException { + Additive_expressionContext _localctx = new Additive_expressionContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_additive_expression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(676); + multiplicative_expression(); + setState(681); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,39,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(677); + _la = _input.LA(1); + if ( !(_la==PLUS || _la==MINUS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(678); + multiplicative_expression(); + } + } + } + setState(683); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,39,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Multiplicative_expressionContext extends ParserRuleContext { + public List switch_expression() { + return getRuleContexts(Switch_expressionContext.class); + } + public Switch_expressionContext switch_expression(int i) { + return getRuleContext(Switch_expressionContext.class,i); + } + public List STAR() { return getTokens(CSharpParser.STAR); } + public TerminalNode STAR(int i) { + return getToken(CSharpParser.STAR, i); + } + public List DIV() { return getTokens(CSharpParser.DIV); } + public TerminalNode DIV(int i) { + return getToken(CSharpParser.DIV, i); + } + public List PERCENT() { return getTokens(CSharpParser.PERCENT); } + public TerminalNode PERCENT(int i) { + return getToken(CSharpParser.PERCENT, i); + } + public Multiplicative_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_multiplicative_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMultiplicative_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMultiplicative_expression(this); + } + } + + public final Multiplicative_expressionContext multiplicative_expression() throws RecognitionException { + Multiplicative_expressionContext _localctx = new Multiplicative_expressionContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_multiplicative_expression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(684); + switch_expression(); + setState(689); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,40,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(685); + _la = _input.LA(1); + if ( !(((((_la - 137)) & ~0x3f) == 0 && ((1L << (_la - 137)) & ((1L << (STAR - 137)) | (1L << (DIV - 137)) | (1L << (PERCENT - 137)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(686); + switch_expression(); + } + } + } + setState(691); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,40,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Switch_expressionContext extends ParserRuleContext { + public Range_expressionContext range_expression() { + return getRuleContext(Range_expressionContext.class,0); + } + public TerminalNode SWITCH() { return getToken(CSharpParser.SWITCH, 0); } + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public Switch_expression_armsContext switch_expression_arms() { + return getRuleContext(Switch_expression_armsContext.class,0); + } + public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } + public Switch_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switch_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSwitch_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSwitch_expression(this); + } + } + + public final Switch_expressionContext switch_expression() throws RecognitionException { + Switch_expressionContext _localctx = new Switch_expressionContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_switch_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(692); + range_expression(); + setState(702); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SWITCH) { + { + setState(693); + match(SWITCH); + setState(694); + match(OPEN_BRACE); + setState(699); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(695); + switch_expression_arms(); + setState(697); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(696); + match(COMMA); + } + } + + } + } + + setState(701); + match(CLOSE_BRACE); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Switch_expression_armsContext extends ParserRuleContext { + public List switch_expression_arm() { + return getRuleContexts(Switch_expression_armContext.class); + } + public Switch_expression_armContext switch_expression_arm(int i) { + return getRuleContext(Switch_expression_armContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Switch_expression_armsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switch_expression_arms; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSwitch_expression_arms(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSwitch_expression_arms(this); + } + } + + public final Switch_expression_armsContext switch_expression_arms() throws RecognitionException { + Switch_expression_armsContext _localctx = new Switch_expression_armsContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_switch_expression_arms); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(704); + switch_expression_arm(); + setState(709); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,44,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(705); + match(COMMA); + setState(706); + switch_expression_arm(); + } + } + } + setState(711); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,44,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Switch_expression_armContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class,0); + } + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class,0); + } + public Case_guardContext case_guard() { + return getRuleContext(Case_guardContext.class,0); + } + public Switch_expression_armContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switch_expression_arm; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSwitch_expression_arm(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSwitch_expression_arm(this); + } + } + + public final Switch_expression_armContext switch_expression_arm() throws RecognitionException { + Switch_expression_armContext _localctx = new Switch_expression_armContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_switch_expression_arm); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(712); + expression(); + setState(714); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHEN) { + { + setState(713); + case_guard(); + } + } + + setState(716); + right_arrow(); + setState(717); + throwable_expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Range_expressionContext extends ParserRuleContext { + public List unary_expression() { + return getRuleContexts(Unary_expressionContext.class); + } + public Unary_expressionContext unary_expression(int i) { + return getRuleContext(Unary_expressionContext.class,i); + } + public TerminalNode OP_RANGE() { return getToken(CSharpParser.OP_RANGE, 0); } + public Range_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_range_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterRange_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitRange_expression(this); + } + } + + public final Range_expressionContext range_expression() throws RecognitionException { + Range_expressionContext _localctx = new Range_expressionContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_range_expression); + int _la; + try { + setState(727); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(719); + unary_expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(721); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)))) != 0)) { + { + setState(720); + unary_expression(); + } + } + + setState(723); + match(OP_RANGE); + setState(725); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { + case 1: + { + setState(724); + unary_expression(); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Unary_expressionContext extends ParserRuleContext { + public Primary_expressionContext primary_expression() { + return getRuleContext(Primary_expressionContext.class,0); + } + public TerminalNode PLUS() { return getToken(CSharpParser.PLUS, 0); } + public Unary_expressionContext unary_expression() { + return getRuleContext(Unary_expressionContext.class,0); + } + public TerminalNode MINUS() { return getToken(CSharpParser.MINUS, 0); } + public TerminalNode BANG() { return getToken(CSharpParser.BANG, 0); } + public TerminalNode TILDE() { return getToken(CSharpParser.TILDE, 0); } + public TerminalNode OP_INC() { return getToken(CSharpParser.OP_INC, 0); } + public TerminalNode OP_DEC() { return getToken(CSharpParser.OP_DEC, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public TerminalNode AWAIT() { return getToken(CSharpParser.AWAIT, 0); } + public TerminalNode AMP() { return getToken(CSharpParser.AMP, 0); } + public TerminalNode STAR() { return getToken(CSharpParser.STAR, 0); } + public TerminalNode CARET() { return getToken(CSharpParser.CARET, 0); } + public Unary_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unary_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterUnary_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitUnary_expression(this); + } + } + + public final Unary_expressionContext unary_expression() throws RecognitionException { + Unary_expressionContext _localctx = new Unary_expressionContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_unary_expression); + try { + setState(755); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(729); + primary_expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(730); + match(PLUS); + setState(731); + unary_expression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(732); + match(MINUS); + setState(733); + unary_expression(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(734); + match(BANG); + setState(735); + unary_expression(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(736); + match(TILDE); + setState(737); + unary_expression(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(738); + match(OP_INC); + setState(739); + unary_expression(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(740); + match(OP_DEC); + setState(741); + unary_expression(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(742); + match(OPEN_PARENS); + setState(743); + type_(); + setState(744); + match(CLOSE_PARENS); + setState(745); + unary_expression(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(747); + match(AWAIT); + setState(748); + unary_expression(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(749); + match(AMP); + setState(750); + unary_expression(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(751); + match(STAR); + setState(752); + unary_expression(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(753); + match(CARET); + setState(754); + unary_expression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Primary_expressionContext extends ParserRuleContext { + public Primary_expression_startContext pe; + public Primary_expression_startContext primary_expression_start() { + return getRuleContext(Primary_expression_startContext.class,0); + } + public List BANG() { return getTokens(CSharpParser.BANG); } + public TerminalNode BANG(int i) { + return getToken(CSharpParser.BANG, i); + } + public List bracket_expression() { + return getRuleContexts(Bracket_expressionContext.class); + } + public Bracket_expressionContext bracket_expression(int i) { + return getRuleContext(Bracket_expressionContext.class,i); + } + public List member_access() { + return getRuleContexts(Member_accessContext.class); + } + public Member_accessContext member_access(int i) { + return getRuleContext(Member_accessContext.class,i); + } + public List method_invocation() { + return getRuleContexts(Method_invocationContext.class); + } + public Method_invocationContext method_invocation(int i) { + return getRuleContext(Method_invocationContext.class,i); + } + public List OP_INC() { return getTokens(CSharpParser.OP_INC); } + public TerminalNode OP_INC(int i) { + return getToken(CSharpParser.OP_INC, i); + } + public List OP_DEC() { return getTokens(CSharpParser.OP_DEC); } + public TerminalNode OP_DEC(int i) { + return getToken(CSharpParser.OP_DEC, i); + } + public List OP_PTR() { return getTokens(CSharpParser.OP_PTR); } + public TerminalNode OP_PTR(int i) { + return getToken(CSharpParser.OP_PTR, i); + } + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public Primary_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primary_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterPrimary_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitPrimary_expression(this); + } + } + + public final Primary_expressionContext primary_expression() throws RecognitionException { + Primary_expressionContext _localctx = new Primary_expressionContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_primary_expression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(757); + ((Primary_expressionContext)_localctx).pe = primary_expression_start(); + setState(759); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { + case 1: + { + setState(758); + match(BANG); + } + break; + } + setState(764); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,51,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(761); + bracket_expression(); + } + } + } + setState(766); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,51,_ctx); + } + setState(768); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { + case 1: + { + setState(767); + match(BANG); + } + break; + } + setState(792); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,57,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + { + setState(776); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT: + case INTERR: + { + setState(770); + member_access(); + } + break; + case OPEN_PARENS: + { + setState(771); + method_invocation(); + } + break; + case OP_INC: + { + setState(772); + match(OP_INC); + } + break; + case OP_DEC: + { + setState(773); + match(OP_DEC); + } + break; + case OP_PTR: + { + setState(774); + match(OP_PTR); + setState(775); + identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(779); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { + case 1: + { + setState(778); + match(BANG); + } + break; + } + } + setState(784); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,55,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(781); + bracket_expression(); + } + } + } + setState(786); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,55,_ctx); + } + setState(788); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) { + case 1: + { + setState(787); + match(BANG); + } + break; + } + } + } + } + setState(794); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,57,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Primary_expression_startContext extends ParserRuleContext { + public Primary_expression_startContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primary_expression_start; } + + public Primary_expression_startContext() { } + public void copyFrom(Primary_expression_startContext ctx) { + super.copyFrom(ctx); + } + } + public static class LiteralAccessExpressionContext extends Primary_expression_startContext { + public TerminalNode LITERAL_ACCESS() { return getToken(CSharpParser.LITERAL_ACCESS, 0); } + public LiteralAccessExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLiteralAccessExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLiteralAccessExpression(this); + } + } + public static class DefaultValueExpressionContext extends Primary_expression_startContext { + public TerminalNode DEFAULT() { return getToken(CSharpParser.DEFAULT, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public DefaultValueExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterDefaultValueExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitDefaultValueExpression(this); + } + } + public static class BaseAccessExpressionContext extends Primary_expression_startContext { + public TerminalNode BASE() { return getToken(CSharpParser.BASE, 0); } + public TerminalNode DOT() { return getToken(CSharpParser.DOT, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } + public Expression_listContext expression_list() { + return getRuleContext(Expression_listContext.class,0); + } + public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } + public Type_argument_listContext type_argument_list() { + return getRuleContext(Type_argument_listContext.class,0); + } + public BaseAccessExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterBaseAccessExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitBaseAccessExpression(this); + } + } + public static class SizeofExpressionContext extends Primary_expression_startContext { + public TerminalNode SIZEOF() { return getToken(CSharpParser.SIZEOF, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public SizeofExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSizeofExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSizeofExpression(this); + } + } + public static class ParenthesisExpressionsContext extends Primary_expression_startContext { + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public ParenthesisExpressionsContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterParenthesisExpressions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitParenthesisExpressions(this); + } + } + public static class ThisReferenceExpressionContext extends Primary_expression_startContext { + public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } + public ThisReferenceExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterThisReferenceExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitThisReferenceExpression(this); + } + } + public static class ObjectCreationExpressionContext extends Primary_expression_startContext { + public TerminalNode NEW() { return getToken(CSharpParser.NEW, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public Anonymous_object_initializerContext anonymous_object_initializer() { + return getRuleContext(Anonymous_object_initializerContext.class,0); + } + public List rank_specifier() { + return getRuleContexts(Rank_specifierContext.class); + } + public Rank_specifierContext rank_specifier(int i) { + return getRuleContext(Rank_specifierContext.class,i); + } + public Array_initializerContext array_initializer() { + return getRuleContext(Array_initializerContext.class,0); + } + public Object_creation_expressionContext object_creation_expression() { + return getRuleContext(Object_creation_expressionContext.class,0); + } + public Object_or_collection_initializerContext object_or_collection_initializer() { + return getRuleContext(Object_or_collection_initializerContext.class,0); + } + public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } + public Expression_listContext expression_list() { + return getRuleContext(Expression_listContext.class,0); + } + public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } + public ObjectCreationExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterObjectCreationExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitObjectCreationExpression(this); + } + } + public static class AnonymousMethodExpressionContext extends Primary_expression_startContext { + public TerminalNode DELEGATE() { return getToken(CSharpParser.DELEGATE, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public TerminalNode ASYNC() { return getToken(CSharpParser.ASYNC, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Explicit_anonymous_function_parameter_listContext explicit_anonymous_function_parameter_list() { + return getRuleContext(Explicit_anonymous_function_parameter_listContext.class,0); + } + public AnonymousMethodExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAnonymousMethodExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAnonymousMethodExpression(this); + } + } + public static class TypeofExpressionContext extends Primary_expression_startContext { + public TerminalNode TYPEOF() { return getToken(CSharpParser.TYPEOF, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Unbound_type_nameContext unbound_type_name() { + return getRuleContext(Unbound_type_nameContext.class,0); + } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } + public TypeofExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterTypeofExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitTypeofExpression(this); + } + } + public static class TupleExpressionContext extends Primary_expression_startContext { + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public List argument() { + return getRuleContexts(ArgumentContext.class); + } + public ArgumentContext argument(int i) { + return getRuleContext(ArgumentContext.class,i); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public TupleExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterTupleExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitTupleExpression(this); + } + } + public static class UncheckedExpressionContext extends Primary_expression_startContext { + public TerminalNode UNCHECKED() { return getToken(CSharpParser.UNCHECKED, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public UncheckedExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterUncheckedExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitUncheckedExpression(this); + } + } + public static class SimpleNameExpressionContext extends Primary_expression_startContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Type_argument_listContext type_argument_list() { + return getRuleContext(Type_argument_listContext.class,0); + } + public SimpleNameExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSimpleNameExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSimpleNameExpression(this); + } + } + public static class MemberAccessExpressionContext extends Primary_expression_startContext { + public Predefined_typeContext predefined_type() { + return getRuleContext(Predefined_typeContext.class,0); + } + public Qualified_alias_memberContext qualified_alias_member() { + return getRuleContext(Qualified_alias_memberContext.class,0); + } + public MemberAccessExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMemberAccessExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMemberAccessExpression(this); + } + } + public static class CheckedExpressionContext extends Primary_expression_startContext { + public TerminalNode CHECKED() { return getToken(CSharpParser.CHECKED, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public CheckedExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterCheckedExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitCheckedExpression(this); + } + } + public static class LiteralExpressionContext extends Primary_expression_startContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public LiteralExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLiteralExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLiteralExpression(this); + } + } + public static class NameofExpressionContext extends Primary_expression_startContext { + public TerminalNode NAMEOF() { return getToken(CSharpParser.NAMEOF, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public List DOT() { return getTokens(CSharpParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(CSharpParser.DOT, i); + } + public NameofExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterNameofExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitNameofExpression(this); + } + } + + public final Primary_expression_startContext primary_expression_start() throws RecognitionException { + Primary_expression_startContext _localctx = new Primary_expression_startContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_primary_expression_start); + int _la; + try { + int _alt; + setState(916); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) { + case 1: + _localctx = new LiteralExpressionContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(795); + literal(); + } + break; + case 2: + _localctx = new SimpleNameExpressionContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(796); + identifier(); + setState(798); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) { + case 1: + { + setState(797); + type_argument_list(); + } + break; + } + } + break; + case 3: + _localctx = new ParenthesisExpressionsContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(800); + match(OPEN_PARENS); + setState(801); + expression(); + setState(802); + match(CLOSE_PARENS); + } + break; + case 4: + _localctx = new MemberAccessExpressionContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(804); + predefined_type(); + } + break; + case 5: + _localctx = new MemberAccessExpressionContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(805); + qualified_alias_member(); + } + break; + case 6: + _localctx = new LiteralAccessExpressionContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(806); + match(LITERAL_ACCESS); + } + break; + case 7: + _localctx = new ThisReferenceExpressionContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(807); + match(THIS); + } + break; + case 8: + _localctx = new BaseAccessExpressionContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(808); + match(BASE); + setState(818); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT: + { + setState(809); + match(DOT); + setState(810); + identifier(); + setState(812); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) { + case 1: + { + setState(811); + type_argument_list(); + } + break; + } + } + break; + case OPEN_BRACKET: + { + setState(814); + match(OPEN_BRACKET); + setState(815); + expression_list(); + setState(816); + match(CLOSE_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 9: + _localctx = new ObjectCreationExpressionContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(820); + match(NEW); + setState(849); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BOOL: + case BY: + case BYTE: + case CHAR: + case DECIMAL: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case STRING: + case UINT: + case ULONG: + case UNMANAGED: + case USHORT: + case VAR: + case VOID: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case OPEN_PARENS: + { + setState(821); + type_(); + setState(843); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) { + case 1: + { + setState(822); + object_creation_expression(); + } + break; + case 2: + { + setState(823); + object_or_collection_initializer(); + } + break; + case 3: + { + setState(824); + match(OPEN_BRACKET); + setState(825); + expression_list(); + setState(826); + match(CLOSE_BRACKET); + setState(830); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,61,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(827); + rank_specifier(); + } + } + } + setState(832); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,61,_ctx); + } + setState(834); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACE) { + { + setState(833); + array_initializer(); + } + } + + } + break; + case 4: + { + setState(837); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(836); + rank_specifier(); + } + } + setState(839); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==OPEN_BRACKET ); + setState(841); + array_initializer(); + } + break; + } + } + break; + case OPEN_BRACE: + { + setState(845); + anonymous_object_initializer(); + } + break; + case OPEN_BRACKET: + { + setState(846); + rank_specifier(); + setState(847); + array_initializer(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 10: + _localctx = new TupleExpressionContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(851); + match(OPEN_PARENS); + setState(852); + argument(); + setState(855); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(853); + match(COMMA); + setState(854); + argument(); + } + } + setState(857); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==COMMA ); + setState(859); + match(CLOSE_PARENS); + } + break; + case 11: + _localctx = new TypeofExpressionContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(861); + match(TYPEOF); + setState(862); + match(OPEN_PARENS); + setState(866); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { + case 1: + { + setState(863); + unbound_type_name(); + } + break; + case 2: + { + setState(864); + type_(); + } + break; + case 3: + { + setState(865); + match(VOID); + } + break; + } + setState(868); + match(CLOSE_PARENS); + } + break; + case 12: + _localctx = new CheckedExpressionContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(869); + match(CHECKED); + setState(870); + match(OPEN_PARENS); + setState(871); + expression(); + setState(872); + match(CLOSE_PARENS); + } + break; + case 13: + _localctx = new UncheckedExpressionContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(874); + match(UNCHECKED); + setState(875); + match(OPEN_PARENS); + setState(876); + expression(); + setState(877); + match(CLOSE_PARENS); + } + break; + case 14: + _localctx = new DefaultValueExpressionContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(879); + match(DEFAULT); + setState(884); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) { + case 1: + { + setState(880); + match(OPEN_PARENS); + setState(881); + type_(); + setState(882); + match(CLOSE_PARENS); + } + break; + } + } + break; + case 15: + _localctx = new AnonymousMethodExpressionContext(_localctx); + enterOuterAlt(_localctx, 15); + { + setState(887); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASYNC) { + { + setState(886); + match(ASYNC); + } + } + + setState(889); + match(DELEGATE); + setState(895); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PARENS) { + { + setState(890); + match(OPEN_PARENS); + setState(892); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (PARTIAL - 75)) | (1L << (REF - 75)) | (1L << (REMOVE - 75)) | (1L << (SBYTE - 75)) | (1L << (SELECT - 75)) | (1L << (SET - 75)) | (1L << (SHORT - 75)) | (1L << (STRING - 75)) | (1L << (UINT - 75)) | (1L << (ULONG - 75)) | (1L << (UNMANAGED - 75)) | (1L << (USHORT - 75)) | (1L << (VAR - 75)) | (1L << (VOID - 75)) | (1L << (WHEN - 75)) | (1L << (WHERE - 75)) | (1L << (YIELD - 75)) | (1L << (IDENTIFIER - 75)) | (1L << (OPEN_PARENS - 75)))) != 0)) { + { + setState(891); + explicit_anonymous_function_parameter_list(); + } + } + + setState(894); + match(CLOSE_PARENS); + } + } + + setState(897); + block(); + } + break; + case 16: + _localctx = new SizeofExpressionContext(_localctx); + enterOuterAlt(_localctx, 16); + { + setState(898); + match(SIZEOF); + setState(899); + match(OPEN_PARENS); + setState(900); + type_(); + setState(901); + match(CLOSE_PARENS); + } + break; + case 17: + _localctx = new NameofExpressionContext(_localctx); + enterOuterAlt(_localctx, 17); + { + setState(903); + match(NAMEOF); + setState(904); + match(OPEN_PARENS); + setState(910); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,72,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(905); + identifier(); + setState(906); + match(DOT); + } + } + } + setState(912); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,72,_ctx); + } + setState(913); + identifier(); + setState(914); + match(CLOSE_PARENS); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Throwable_expressionContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Throw_expressionContext throw_expression() { + return getRuleContext(Throw_expressionContext.class,0); + } + public Throwable_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_throwable_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterThrowable_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitThrowable_expression(this); + } + } + + public final Throwable_expressionContext throwable_expression() throws RecognitionException { + Throwable_expressionContext _localctx = new Throwable_expressionContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_throwable_expression); + try { + setState(920); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(918); + expression(); + } + break; + case THROW: + enterOuterAlt(_localctx, 2); + { + setState(919); + throw_expression(); + } + 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 Throw_expressionContext extends ParserRuleContext { + public TerminalNode THROW() { return getToken(CSharpParser.THROW, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Throw_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_throw_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterThrow_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitThrow_expression(this); + } + } + + public final Throw_expressionContext throw_expression() throws RecognitionException { + Throw_expressionContext _localctx = new Throw_expressionContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_throw_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(922); + match(THROW); + setState(923); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Member_accessContext extends ParserRuleContext { + public TerminalNode DOT() { return getToken(CSharpParser.DOT, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode INTERR() { return getToken(CSharpParser.INTERR, 0); } + public Type_argument_listContext type_argument_list() { + return getRuleContext(Type_argument_listContext.class,0); + } + public Member_accessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_member_access; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMember_access(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMember_access(this); + } + } + + public final Member_accessContext member_access() throws RecognitionException { + Member_accessContext _localctx = new Member_accessContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_member_access); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(926); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTERR) { + { + setState(925); + match(INTERR); + } + } + + setState(928); + match(DOT); + setState(929); + identifier(); + setState(931); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) { + case 1: + { + setState(930); + type_argument_list(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Bracket_expressionContext extends ParserRuleContext { + public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } + public List indexer_argument() { + return getRuleContexts(Indexer_argumentContext.class); + } + public Indexer_argumentContext indexer_argument(int i) { + return getRuleContext(Indexer_argumentContext.class,i); + } + public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } + public TerminalNode INTERR() { return getToken(CSharpParser.INTERR, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Bracket_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_bracket_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterBracket_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitBracket_expression(this); + } + } + + public final Bracket_expressionContext bracket_expression() throws RecognitionException { + Bracket_expressionContext _localctx = new Bracket_expressionContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_bracket_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(934); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTERR) { + { + setState(933); + match(INTERR); + } + } + + setState(936); + match(OPEN_BRACKET); + setState(937); + indexer_argument(); + setState(942); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(938); + match(COMMA); + setState(939); + indexer_argument(); + } + } + setState(944); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(945); + match(CLOSE_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Indexer_argumentContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public Indexer_argumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexer_argument; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterIndexer_argument(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitIndexer_argument(this); + } + } + + public final Indexer_argumentContext indexer_argument() throws RecognitionException { + Indexer_argumentContext _localctx = new Indexer_argumentContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_indexer_argument); + try { + enterOuterAlt(_localctx, 1); + { + setState(950); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) { + case 1: + { + setState(947); + identifier(); + setState(948); + match(COLON); + } + break; + } + setState(952); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Predefined_typeContext extends ParserRuleContext { + public TerminalNode BOOL() { return getToken(CSharpParser.BOOL, 0); } + public TerminalNode BYTE() { return getToken(CSharpParser.BYTE, 0); } + public TerminalNode CHAR() { return getToken(CSharpParser.CHAR, 0); } + public TerminalNode DECIMAL() { return getToken(CSharpParser.DECIMAL, 0); } + public TerminalNode DOUBLE() { return getToken(CSharpParser.DOUBLE, 0); } + public TerminalNode FLOAT() { return getToken(CSharpParser.FLOAT, 0); } + public TerminalNode INT() { return getToken(CSharpParser.INT, 0); } + public TerminalNode LONG() { return getToken(CSharpParser.LONG, 0); } + public TerminalNode OBJECT() { return getToken(CSharpParser.OBJECT, 0); } + public TerminalNode SBYTE() { return getToken(CSharpParser.SBYTE, 0); } + public TerminalNode SHORT() { return getToken(CSharpParser.SHORT, 0); } + public TerminalNode STRING() { return getToken(CSharpParser.STRING, 0); } + public TerminalNode UINT() { return getToken(CSharpParser.UINT, 0); } + public TerminalNode ULONG() { return getToken(CSharpParser.ULONG, 0); } + public TerminalNode USHORT() { return getToken(CSharpParser.USHORT, 0); } + public Predefined_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_predefined_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterPredefined_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitPredefined_type(this); + } + } + + public final Predefined_typeContext predefined_type() throws RecognitionException { + Predefined_typeContext _localctx = new Predefined_typeContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_predefined_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(954); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOL) | (1L << BYTE) | (1L << CHAR) | (1L << DECIMAL) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (OBJECT - 68)) | (1L << (SBYTE - 68)) | (1L << (SHORT - 68)) | (1L << (STRING - 68)) | (1L << (UINT - 68)) | (1L << (ULONG - 68)) | (1L << (USHORT - 68)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Expression_listContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Expression_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterExpression_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitExpression_list(this); + } + } + + public final Expression_listContext expression_list() throws RecognitionException { + Expression_listContext _localctx = new Expression_listContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_expression_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(956); + expression(); + setState(961); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(957); + match(COMMA); + setState(958); + expression(); + } + } + setState(963); + _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 Object_or_collection_initializerContext extends ParserRuleContext { + public Object_initializerContext object_initializer() { + return getRuleContext(Object_initializerContext.class,0); + } + public Collection_initializerContext collection_initializer() { + return getRuleContext(Collection_initializerContext.class,0); + } + public Object_or_collection_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_object_or_collection_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterObject_or_collection_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitObject_or_collection_initializer(this); + } + } + + public final Object_or_collection_initializerContext object_or_collection_initializer() throws RecognitionException { + Object_or_collection_initializerContext _localctx = new Object_or_collection_initializerContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_object_or_collection_initializer); + try { + setState(966); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(964); + object_initializer(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(965); + collection_initializer(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Object_initializerContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public Member_initializer_listContext member_initializer_list() { + return getRuleContext(Member_initializer_listContext.class,0); + } + public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } + public Object_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_object_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterObject_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitObject_initializer(this); + } + } + + public final Object_initializerContext object_initializer() throws RecognitionException { + Object_initializerContext _localctx = new Object_initializerContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_object_initializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(968); + match(OPEN_BRACE); + setState(973); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (OPEN_BRACKET - 64)))) != 0)) { + { + setState(969); + member_initializer_list(); + setState(971); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(970); + match(COMMA); + } + } + + } + } + + setState(975); + match(CLOSE_BRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Member_initializer_listContext extends ParserRuleContext { + public List member_initializer() { + return getRuleContexts(Member_initializerContext.class); + } + public Member_initializerContext member_initializer(int i) { + return getRuleContext(Member_initializerContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Member_initializer_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_member_initializer_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMember_initializer_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMember_initializer_list(this); + } + } + + public final Member_initializer_listContext member_initializer_list() throws RecognitionException { + Member_initializer_listContext _localctx = new Member_initializer_listContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_member_initializer_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(977); + member_initializer(); + setState(982); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,84,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(978); + match(COMMA); + setState(979); + member_initializer(); + } + } + } + setState(984); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,84,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Member_initializerContext extends ParserRuleContext { + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public Initializer_valueContext initializer_value() { + return getRuleContext(Initializer_valueContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } + public Member_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_member_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMember_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMember_initializer(this); + } + } + + public final Member_initializerContext member_initializer() throws RecognitionException { + Member_initializerContext _localctx = new Member_initializerContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_member_initializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(990); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BY: + case DESCENDING: + case DYNAMIC: + case EQUALS: + case FROM: + case GET: + case GROUP: + case INTO: + case JOIN: + case LET: + case NAMEOF: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SELECT: + case SET: + case UNMANAGED: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + { + setState(985); + identifier(); + } + break; + case OPEN_BRACKET: + { + setState(986); + match(OPEN_BRACKET); + setState(987); + expression(); + setState(988); + match(CLOSE_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + setState(992); + match(ASSIGNMENT); + setState(993); + initializer_value(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Initializer_valueContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Object_or_collection_initializerContext object_or_collection_initializer() { + return getRuleContext(Object_or_collection_initializerContext.class,0); + } + public Initializer_valueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_initializer_value; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInitializer_value(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInitializer_value(this); + } + } + + public final Initializer_valueContext initializer_value() throws RecognitionException { + Initializer_valueContext _localctx = new Initializer_valueContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_initializer_value); + try { + setState(997); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(995); + expression(); + } + break; + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(996); + object_or_collection_initializer(); + } + 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 Collection_initializerContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public List element_initializer() { + return getRuleContexts(Element_initializerContext.class); + } + public Element_initializerContext element_initializer(int i) { + return getRuleContext(Element_initializerContext.class,i); + } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Collection_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_collection_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterCollection_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitCollection_initializer(this); + } + } + + public final Collection_initializerContext collection_initializer() throws RecognitionException { + Collection_initializerContext _localctx = new Collection_initializerContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_collection_initializer); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(999); + match(OPEN_BRACE); + setState(1000); + element_initializer(); + setState(1005); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,87,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1001); + match(COMMA); + setState(1002); + element_initializer(); + } + } + } + setState(1007); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,87,_ctx); + } + setState(1009); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1008); + match(COMMA); + } + } + + setState(1011); + match(CLOSE_BRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Element_initializerContext extends ParserRuleContext { + public Non_assignment_expressionContext non_assignment_expression() { + return getRuleContext(Non_assignment_expressionContext.class,0); + } + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public Expression_listContext expression_list() { + return getRuleContext(Expression_listContext.class,0); + } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public Element_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_element_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterElement_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitElement_initializer(this); + } + } + + public final Element_initializerContext element_initializer() throws RecognitionException { + Element_initializerContext _localctx = new Element_initializerContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_element_initializer); + try { + setState(1018); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(1013); + non_assignment_expression(); + } + break; + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(1014); + match(OPEN_BRACE); + setState(1015); + expression_list(); + setState(1016); + match(CLOSE_BRACE); + } + 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 Anonymous_object_initializerContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public Member_declarator_listContext member_declarator_list() { + return getRuleContext(Member_declarator_listContext.class,0); + } + public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } + public Anonymous_object_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_anonymous_object_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAnonymous_object_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAnonymous_object_initializer(this); + } + } + + public final Anonymous_object_initializerContext anonymous_object_initializer() throws RecognitionException { + Anonymous_object_initializerContext _localctx = new Anonymous_object_initializerContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_anonymous_object_initializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1020); + match(OPEN_BRACE); + setState(1025); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BASE - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (CHECKED - 10)) | (1L << (DECIMAL - 10)) | (1L << (DEFAULT - 10)) | (1L << (DELEGATE - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FALSE - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (NEW - 10)) | (1L << (NULL_ - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (PARTIAL - 75)) | (1L << (REMOVE - 75)) | (1L << (SBYTE - 75)) | (1L << (SELECT - 75)) | (1L << (SET - 75)) | (1L << (SHORT - 75)) | (1L << (SIZEOF - 75)) | (1L << (STRING - 75)) | (1L << (THIS - 75)) | (1L << (TRUE - 75)) | (1L << (TYPEOF - 75)) | (1L << (UINT - 75)) | (1L << (ULONG - 75)) | (1L << (UNCHECKED - 75)) | (1L << (UNMANAGED - 75)) | (1L << (USHORT - 75)) | (1L << (VAR - 75)) | (1L << (WHEN - 75)) | (1L << (WHERE - 75)) | (1L << (YIELD - 75)) | (1L << (IDENTIFIER - 75)) | (1L << (LITERAL_ACCESS - 75)) | (1L << (INTEGER_LITERAL - 75)) | (1L << (HEX_INTEGER_LITERAL - 75)) | (1L << (BIN_INTEGER_LITERAL - 75)) | (1L << (REAL_LITERAL - 75)) | (1L << (CHARACTER_LITERAL - 75)) | (1L << (REGULAR_STRING - 75)) | (1L << (VERBATIUM_STRING - 75)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 75)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 75)) | (1L << (OPEN_PARENS - 75)))) != 0)) { + { + setState(1021); + member_declarator_list(); + setState(1023); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1022); + match(COMMA); + } + } + + } + } + + setState(1027); + match(CLOSE_BRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Member_declarator_listContext extends ParserRuleContext { + public List member_declarator() { + return getRuleContexts(Member_declaratorContext.class); + } + public Member_declaratorContext member_declarator(int i) { + return getRuleContext(Member_declaratorContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Member_declarator_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_member_declarator_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMember_declarator_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMember_declarator_list(this); + } + } + + public final Member_declarator_listContext member_declarator_list() throws RecognitionException { + Member_declarator_listContext _localctx = new Member_declarator_listContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_member_declarator_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1029); + member_declarator(); + setState(1034); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,92,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1030); + match(COMMA); + setState(1031); + member_declarator(); + } + } + } + setState(1036); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,92,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Member_declaratorContext extends ParserRuleContext { + public Primary_expressionContext primary_expression() { + return getRuleContext(Primary_expressionContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Member_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_member_declarator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMember_declarator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMember_declarator(this); + } + } + + public final Member_declaratorContext member_declarator() throws RecognitionException { + Member_declaratorContext _localctx = new Member_declaratorContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_member_declarator); + try { + setState(1042); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1037); + primary_expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1038); + identifier(); + setState(1039); + match(ASSIGNMENT); + setState(1040); + expression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Unbound_type_nameContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public TerminalNode DOUBLE_COLON() { return getToken(CSharpParser.DOUBLE_COLON, 0); } + public List DOT() { return getTokens(CSharpParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(CSharpParser.DOT, i); + } + public List generic_dimension_specifier() { + return getRuleContexts(Generic_dimension_specifierContext.class); + } + public Generic_dimension_specifierContext generic_dimension_specifier(int i) { + return getRuleContext(Generic_dimension_specifierContext.class,i); + } + public Unbound_type_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unbound_type_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterUnbound_type_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitUnbound_type_name(this); + } + } + + public final Unbound_type_nameContext unbound_type_name() throws RecognitionException { + Unbound_type_nameContext _localctx = new Unbound_type_nameContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_unbound_type_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1044); + identifier(); + setState(1053); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CLOSE_PARENS: + case DOT: + case LT: + { + setState(1046); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1045); + generic_dimension_specifier(); + } + } + + } + break; + case DOUBLE_COLON: + { + setState(1048); + match(DOUBLE_COLON); + setState(1049); + identifier(); + setState(1051); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1050); + generic_dimension_specifier(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + setState(1062); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(1055); + match(DOT); + setState(1056); + identifier(); + setState(1058); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1057); + generic_dimension_specifier(); + } + } + + } + } + setState(1064); + _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 Generic_dimension_specifierContext extends ParserRuleContext { + public TerminalNode LT() { return getToken(CSharpParser.LT, 0); } + public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Generic_dimension_specifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generic_dimension_specifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterGeneric_dimension_specifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitGeneric_dimension_specifier(this); + } + } + + public final Generic_dimension_specifierContext generic_dimension_specifier() throws RecognitionException { + Generic_dimension_specifierContext _localctx = new Generic_dimension_specifierContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_generic_dimension_specifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1065); + match(LT); + setState(1069); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1066); + match(COMMA); + } + } + setState(1071); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1072); + match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IsTypeContext extends ParserRuleContext { + public Base_typeContext base_type() { + return getRuleContext(Base_typeContext.class,0); + } + public List rank_specifier() { + return getRuleContexts(Rank_specifierContext.class); + } + public Rank_specifierContext rank_specifier(int i) { + return getRuleContext(Rank_specifierContext.class,i); + } + public List STAR() { return getTokens(CSharpParser.STAR); } + public TerminalNode STAR(int i) { + return getToken(CSharpParser.STAR, i); + } + public TerminalNode INTERR() { return getToken(CSharpParser.INTERR, 0); } + public IsTypePatternArmsContext isTypePatternArms() { + return getRuleContext(IsTypePatternArmsContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public IsTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_isType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterIsType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitIsType(this); + } + } + + public final IsTypeContext isType() throws RecognitionException { + IsTypeContext _localctx = new IsTypeContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_isType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1074); + base_type(); + setState(1079); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,101,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(1077); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACKET: + { + setState(1075); + rank_specifier(); + } + break; + case STAR: + { + setState(1076); + match(STAR); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(1081); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,101,_ctx); + } + setState(1083); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) { + case 1: + { + setState(1082); + match(INTERR); + } + break; + } + setState(1086); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACE) { + { + setState(1085); + isTypePatternArms(); + } + } + + setState(1089); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) { + case 1: + { + setState(1088); + identifier(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IsTypePatternArmsContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public List isTypePatternArm() { + return getRuleContexts(IsTypePatternArmContext.class); + } + public IsTypePatternArmContext isTypePatternArm(int i) { + return getRuleContext(IsTypePatternArmContext.class,i); + } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public IsTypePatternArmsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_isTypePatternArms; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterIsTypePatternArms(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitIsTypePatternArms(this); + } + } + + public final IsTypePatternArmsContext isTypePatternArms() throws RecognitionException { + IsTypePatternArmsContext _localctx = new IsTypePatternArmsContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_isTypePatternArms); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1091); + match(OPEN_BRACE); + setState(1092); + isTypePatternArm(); + setState(1097); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1093); + match(COMMA); + setState(1094); + isTypePatternArm(); + } + } + setState(1099); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1100); + match(CLOSE_BRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IsTypePatternArmContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public IsTypePatternArmContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_isTypePatternArm; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterIsTypePatternArm(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitIsTypePatternArm(this); + } + } + + public final IsTypePatternArmContext isTypePatternArm() throws RecognitionException { + IsTypePatternArmContext _localctx = new IsTypePatternArmContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_isTypePatternArm); + try { + enterOuterAlt(_localctx, 1); + { + setState(1102); + identifier(); + setState(1103); + match(COLON); + setState(1104); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Lambda_expressionContext extends ParserRuleContext { + public Anonymous_function_signatureContext anonymous_function_signature() { + return getRuleContext(Anonymous_function_signatureContext.class,0); + } + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class,0); + } + public Anonymous_function_bodyContext anonymous_function_body() { + return getRuleContext(Anonymous_function_bodyContext.class,0); + } + public TerminalNode ASYNC() { return getToken(CSharpParser.ASYNC, 0); } + public Lambda_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambda_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLambda_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLambda_expression(this); + } + } + + public final Lambda_expressionContext lambda_expression() throws RecognitionException { + Lambda_expressionContext _localctx = new Lambda_expressionContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_lambda_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(1107); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) { + case 1: + { + setState(1106); + match(ASYNC); + } + break; + } + setState(1109); + anonymous_function_signature(); + setState(1110); + right_arrow(); + setState(1111); + anonymous_function_body(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Anonymous_function_signatureContext extends ParserRuleContext { + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Explicit_anonymous_function_parameter_listContext explicit_anonymous_function_parameter_list() { + return getRuleContext(Explicit_anonymous_function_parameter_listContext.class,0); + } + public Implicit_anonymous_function_parameter_listContext implicit_anonymous_function_parameter_list() { + return getRuleContext(Implicit_anonymous_function_parameter_listContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Anonymous_function_signatureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_anonymous_function_signature; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAnonymous_function_signature(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAnonymous_function_signature(this); + } + } + + public final Anonymous_function_signatureContext anonymous_function_signature() throws RecognitionException { + Anonymous_function_signatureContext _localctx = new Anonymous_function_signatureContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_anonymous_function_signature); + try { + setState(1124); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1113); + match(OPEN_PARENS); + setState(1114); + match(CLOSE_PARENS); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1115); + match(OPEN_PARENS); + setState(1116); + explicit_anonymous_function_parameter_list(); + setState(1117); + match(CLOSE_PARENS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1119); + match(OPEN_PARENS); + setState(1120); + implicit_anonymous_function_parameter_list(); + setState(1121); + match(CLOSE_PARENS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1123); + identifier(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Explicit_anonymous_function_parameter_listContext extends ParserRuleContext { + public List explicit_anonymous_function_parameter() { + return getRuleContexts(Explicit_anonymous_function_parameterContext.class); + } + public Explicit_anonymous_function_parameterContext explicit_anonymous_function_parameter(int i) { + return getRuleContext(Explicit_anonymous_function_parameterContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Explicit_anonymous_function_parameter_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explicit_anonymous_function_parameter_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterExplicit_anonymous_function_parameter_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitExplicit_anonymous_function_parameter_list(this); + } + } + + public final Explicit_anonymous_function_parameter_listContext explicit_anonymous_function_parameter_list() throws RecognitionException { + Explicit_anonymous_function_parameter_listContext _localctx = new Explicit_anonymous_function_parameter_listContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_explicit_anonymous_function_parameter_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1126); + explicit_anonymous_function_parameter(); + setState(1131); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1127); + match(COMMA); + setState(1128); + explicit_anonymous_function_parameter(); + } + } + setState(1133); + _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 Explicit_anonymous_function_parameterContext extends ParserRuleContext { + public Token refout; + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } + public TerminalNode OUT() { return getToken(CSharpParser.OUT, 0); } + public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } + public Explicit_anonymous_function_parameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explicit_anonymous_function_parameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterExplicit_anonymous_function_parameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitExplicit_anonymous_function_parameter(this); + } + } + + public final Explicit_anonymous_function_parameterContext explicit_anonymous_function_parameter() throws RecognitionException { + Explicit_anonymous_function_parameterContext _localctx = new Explicit_anonymous_function_parameterContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_explicit_anonymous_function_parameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1135); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & ((1L << (IN - 54)) | (1L << (OUT - 54)) | (1L << (REF - 54)))) != 0)) { + { + setState(1134); + ((Explicit_anonymous_function_parameterContext)_localctx).refout = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & ((1L << (IN - 54)) | (1L << (OUT - 54)) | (1L << (REF - 54)))) != 0)) ) { + ((Explicit_anonymous_function_parameterContext)_localctx).refout = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(1137); + type_(); + setState(1138); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Implicit_anonymous_function_parameter_listContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Implicit_anonymous_function_parameter_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_implicit_anonymous_function_parameter_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterImplicit_anonymous_function_parameter_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitImplicit_anonymous_function_parameter_list(this); + } + } + + public final Implicit_anonymous_function_parameter_listContext implicit_anonymous_function_parameter_list() throws RecognitionException { + Implicit_anonymous_function_parameter_listContext _localctx = new Implicit_anonymous_function_parameter_listContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_implicit_anonymous_function_parameter_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1140); + identifier(); + setState(1145); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1141); + match(COMMA); + setState(1142); + identifier(); + } + } + setState(1147); + _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 Anonymous_function_bodyContext extends ParserRuleContext { + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public Anonymous_function_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_anonymous_function_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAnonymous_function_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAnonymous_function_body(this); + } + } + + public final Anonymous_function_bodyContext anonymous_function_body() throws RecognitionException { + Anonymous_function_bodyContext _localctx = new Anonymous_function_bodyContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_anonymous_function_body); + try { + setState(1150); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case THROW: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(1148); + throwable_expression(); + } + break; + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(1149); + 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 Query_expressionContext extends ParserRuleContext { + public From_clauseContext from_clause() { + return getRuleContext(From_clauseContext.class,0); + } + public Query_bodyContext query_body() { + return getRuleContext(Query_bodyContext.class,0); + } + public Query_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_query_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterQuery_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitQuery_expression(this); + } + } + + public final Query_expressionContext query_expression() throws RecognitionException { + Query_expressionContext _localctx = new Query_expressionContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_query_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(1152); + from_clause(); + setState(1153); + query_body(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class From_clauseContext extends ParserRuleContext { + public TerminalNode FROM() { return getToken(CSharpParser.FROM, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public From_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_from_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFrom_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFrom_clause(this); + } + } + + public final From_clauseContext from_clause() throws RecognitionException { + From_clauseContext _localctx = new From_clauseContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_from_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1155); + match(FROM); + setState(1157); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) { + case 1: + { + setState(1156); + type_(); + } + break; + } + setState(1159); + identifier(); + setState(1160); + match(IN); + setState(1161); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Query_bodyContext extends ParserRuleContext { + public Select_or_group_clauseContext select_or_group_clause() { + return getRuleContext(Select_or_group_clauseContext.class,0); + } + public List query_body_clause() { + return getRuleContexts(Query_body_clauseContext.class); + } + public Query_body_clauseContext query_body_clause(int i) { + return getRuleContext(Query_body_clauseContext.class,i); + } + public Query_continuationContext query_continuation() { + return getRuleContext(Query_continuationContext.class,0); + } + public Query_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_query_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterQuery_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitQuery_body(this); + } + } + + public final Query_bodyContext query_body() throws RecognitionException { + Query_bodyContext _localctx = new Query_bodyContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_query_body); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1166); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 48)) & ~0x3f) == 0 && ((1L << (_la - 48)) & ((1L << (FROM - 48)) | (1L << (JOIN - 48)) | (1L << (LET - 48)) | (1L << (ORDERBY - 48)) | (1L << (WHERE - 48)))) != 0)) { + { + { + setState(1163); + query_body_clause(); + } + } + setState(1168); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1169); + select_or_group_clause(); + setState(1171); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) { + case 1: + { + setState(1170); + query_continuation(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Query_body_clauseContext extends ParserRuleContext { + public From_clauseContext from_clause() { + return getRuleContext(From_clauseContext.class,0); + } + public Let_clauseContext let_clause() { + return getRuleContext(Let_clauseContext.class,0); + } + public Where_clauseContext where_clause() { + return getRuleContext(Where_clauseContext.class,0); + } + public Combined_join_clauseContext combined_join_clause() { + return getRuleContext(Combined_join_clauseContext.class,0); + } + public Orderby_clauseContext orderby_clause() { + return getRuleContext(Orderby_clauseContext.class,0); + } + public Query_body_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_query_body_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterQuery_body_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitQuery_body_clause(this); + } + } + + public final Query_body_clauseContext query_body_clause() throws RecognitionException { + Query_body_clauseContext _localctx = new Query_body_clauseContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_query_body_clause); + try { + setState(1178); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FROM: + enterOuterAlt(_localctx, 1); + { + setState(1173); + from_clause(); + } + break; + case LET: + enterOuterAlt(_localctx, 2); + { + setState(1174); + let_clause(); + } + break; + case WHERE: + enterOuterAlt(_localctx, 3); + { + setState(1175); + where_clause(); + } + break; + case JOIN: + enterOuterAlt(_localctx, 4); + { + setState(1176); + combined_join_clause(); + } + break; + case ORDERBY: + enterOuterAlt(_localctx, 5); + { + setState(1177); + orderby_clause(); + } + 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 Let_clauseContext extends ParserRuleContext { + public TerminalNode LET() { return getToken(CSharpParser.LET, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Let_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_let_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLet_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLet_clause(this); + } + } + + public final Let_clauseContext let_clause() throws RecognitionException { + Let_clauseContext _localctx = new Let_clauseContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_let_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1180); + match(LET); + setState(1181); + identifier(); + setState(1182); + match(ASSIGNMENT); + setState(1183); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Where_clauseContext extends ParserRuleContext { + public TerminalNode WHERE() { return getToken(CSharpParser.WHERE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Where_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_where_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterWhere_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitWhere_clause(this); + } + } + + public final Where_clauseContext where_clause() throws RecognitionException { + Where_clauseContext _localctx = new Where_clauseContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_where_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1185); + match(WHERE); + setState(1186); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Combined_join_clauseContext extends ParserRuleContext { + public TerminalNode JOIN() { return getToken(CSharpParser.JOIN, 0); } + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode ON() { return getToken(CSharpParser.ON, 0); } + public TerminalNode EQUALS() { return getToken(CSharpParser.EQUALS, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode INTO() { return getToken(CSharpParser.INTO, 0); } + public Combined_join_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_combined_join_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterCombined_join_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitCombined_join_clause(this); + } + } + + public final Combined_join_clauseContext combined_join_clause() throws RecognitionException { + Combined_join_clauseContext _localctx = new Combined_join_clauseContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_combined_join_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1188); + match(JOIN); + setState(1190); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) { + case 1: + { + setState(1189); + type_(); + } + break; + } + setState(1192); + identifier(); + setState(1193); + match(IN); + setState(1194); + expression(); + setState(1195); + match(ON); + setState(1196); + expression(); + setState(1197); + match(EQUALS); + setState(1198); + expression(); + setState(1201); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTO) { + { + setState(1199); + match(INTO); + setState(1200); + identifier(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Orderby_clauseContext extends ParserRuleContext { + public TerminalNode ORDERBY() { return getToken(CSharpParser.ORDERBY, 0); } + public List ordering() { + return getRuleContexts(OrderingContext.class); + } + public OrderingContext ordering(int i) { + return getRuleContext(OrderingContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Orderby_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_orderby_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterOrderby_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitOrderby_clause(this); + } + } + + public final Orderby_clauseContext orderby_clause() throws RecognitionException { + Orderby_clauseContext _localctx = new Orderby_clauseContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_orderby_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1203); + match(ORDERBY); + setState(1204); + ordering(); + setState(1209); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1205); + match(COMMA); + setState(1206); + ordering(); + } + } + setState(1211); + _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 OrderingContext extends ParserRuleContext { + public Token dir; + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode ASCENDING() { return getToken(CSharpParser.ASCENDING, 0); } + public TerminalNode DESCENDING() { return getToken(CSharpParser.DESCENDING, 0); } + public OrderingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ordering; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterOrdering(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitOrdering(this); + } + } + + public final OrderingContext ordering() throws RecognitionException { + OrderingContext _localctx = new OrderingContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_ordering); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1212); + expression(); + setState(1214); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASCENDING || _la==DESCENDING) { + { + setState(1213); + ((OrderingContext)_localctx).dir = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ASCENDING || _la==DESCENDING) ) { + ((OrderingContext)_localctx).dir = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Select_or_group_clauseContext extends ParserRuleContext { + public TerminalNode SELECT() { return getToken(CSharpParser.SELECT, 0); } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode GROUP() { return getToken(CSharpParser.GROUP, 0); } + public TerminalNode BY() { return getToken(CSharpParser.BY, 0); } + public Select_or_group_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_select_or_group_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSelect_or_group_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSelect_or_group_clause(this); + } + } + + public final Select_or_group_clauseContext select_or_group_clause() throws RecognitionException { + Select_or_group_clauseContext _localctx = new Select_or_group_clauseContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_select_or_group_clause); + try { + setState(1223); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + enterOuterAlt(_localctx, 1); + { + setState(1216); + match(SELECT); + setState(1217); + expression(); + } + break; + case GROUP: + enterOuterAlt(_localctx, 2); + { + setState(1218); + match(GROUP); + setState(1219); + expression(); + setState(1220); + match(BY); + setState(1221); + expression(); + } + 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 Query_continuationContext extends ParserRuleContext { + public TerminalNode INTO() { return getToken(CSharpParser.INTO, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Query_bodyContext query_body() { + return getRuleContext(Query_bodyContext.class,0); + } + public Query_continuationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_query_continuation; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterQuery_continuation(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitQuery_continuation(this); + } + } + + public final Query_continuationContext query_continuation() throws RecognitionException { + Query_continuationContext _localctx = new Query_continuationContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_query_continuation); + try { + enterOuterAlt(_localctx, 1); + { + setState(1225); + match(INTO); + setState(1226); + identifier(); + setState(1227); + query_body(); + } + } + 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 Labeled_StatementContext labeled_Statement() { + return getRuleContext(Labeled_StatementContext.class,0); + } + public DeclarationStatementContext declarationStatement() { + return getRuleContext(DeclarationStatementContext.class,0); + } + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class,0); + } + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitStatement(this); + } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_statement); + try { + setState(1232); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1229); + labeled_Statement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1230); + declarationStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1231); + embedded_statement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DeclarationStatementContext extends ParserRuleContext { + public Local_variable_declarationContext local_variable_declaration() { + return getRuleContext(Local_variable_declarationContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Local_constant_declarationContext local_constant_declaration() { + return getRuleContext(Local_constant_declarationContext.class,0); + } + public Local_function_declarationContext local_function_declaration() { + return getRuleContext(Local_function_declarationContext.class,0); + } + public DeclarationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declarationStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterDeclarationStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitDeclarationStatement(this); + } + } + + public final DeclarationStatementContext declarationStatement() throws RecognitionException { + DeclarationStatementContext _localctx = new DeclarationStatementContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_declarationStatement); + try { + setState(1241); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1234); + local_variable_declaration(); + setState(1235); + match(SEMICOLON); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1237); + local_constant_declaration(); + setState(1238); + match(SEMICOLON); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1240); + local_function_declaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Local_function_declarationContext extends ParserRuleContext { + public Local_function_headerContext local_function_header() { + return getRuleContext(Local_function_headerContext.class,0); + } + public Local_function_bodyContext local_function_body() { + return getRuleContext(Local_function_bodyContext.class,0); + } + public Local_function_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_local_function_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLocal_function_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLocal_function_declaration(this); + } + } + + public final Local_function_declarationContext local_function_declaration() throws RecognitionException { + Local_function_declarationContext _localctx = new Local_function_declarationContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_local_function_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1243); + local_function_header(); + setState(1244); + local_function_body(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Local_function_headerContext extends ParserRuleContext { + public Return_typeContext return_type() { + return getRuleContext(Return_typeContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Local_function_modifiersContext local_function_modifiers() { + return getRuleContext(Local_function_modifiersContext.class,0); + } + public Type_parameter_listContext type_parameter_list() { + return getRuleContext(Type_parameter_listContext.class,0); + } + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class,0); + } + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class,0); + } + public Local_function_headerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_local_function_header; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLocal_function_header(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLocal_function_header(this); + } + } + + public final Local_function_headerContext local_function_header() throws RecognitionException { + Local_function_headerContext _localctx = new Local_function_headerContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_local_function_header); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1247); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) { + case 1: + { + setState(1246); + local_function_modifiers(); + } + break; + } + setState(1249); + return_type(); + setState(1250); + identifier(); + setState(1252); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1251); + type_parameter_list(); + } + } + + setState(1254); + match(OPEN_PARENS); + setState(1256); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { + { + setState(1255); + formal_parameter_list(); + } + } + + setState(1258); + match(CLOSE_PARENS); + setState(1260); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(1259); + type_parameter_constraints_clauses(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Local_function_modifiersContext extends ParserRuleContext { + public TerminalNode ASYNC() { return getToken(CSharpParser.ASYNC, 0); } + public TerminalNode UNSAFE() { return getToken(CSharpParser.UNSAFE, 0); } + public TerminalNode STATIC() { return getToken(CSharpParser.STATIC, 0); } + public Local_function_modifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_local_function_modifiers; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLocal_function_modifiers(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLocal_function_modifiers(this); + } + } + + public final Local_function_modifiersContext local_function_modifiers() throws RecognitionException { + Local_function_modifiersContext _localctx = new Local_function_modifiersContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_local_function_modifiers); + int _la; + try { + setState(1268); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ASYNC: + case UNSAFE: + enterOuterAlt(_localctx, 1); + { + setState(1262); + _la = _input.LA(1); + if ( !(_la==ASYNC || _la==UNSAFE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1264); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STATIC) { + { + setState(1263); + match(STATIC); + } + } + + } + break; + case STATIC: + enterOuterAlt(_localctx, 2); + { + setState(1266); + match(STATIC); + setState(1267); + _la = _input.LA(1); + if ( !(_la==ASYNC || _la==UNSAFE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + 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 Local_function_bodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class,0); + } + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Local_function_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_local_function_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLocal_function_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLocal_function_body(this); + } + } + + public final Local_function_bodyContext local_function_body() throws RecognitionException { + Local_function_bodyContext _localctx = new Local_function_bodyContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_local_function_body); + try { + setState(1275); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1270); + block(); + } + break; + case ASSIGNMENT: + enterOuterAlt(_localctx, 2); + { + setState(1271); + right_arrow(); + setState(1272); + throwable_expression(); + setState(1273); + match(SEMICOLON); + } + 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 Labeled_StatementContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public Labeled_StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_labeled_Statement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLabeled_Statement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLabeled_Statement(this); + } + } + + public final Labeled_StatementContext labeled_Statement() throws RecognitionException { + Labeled_StatementContext _localctx = new Labeled_StatementContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_labeled_Statement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1277); + identifier(); + setState(1278); + match(COLON); + setState(1279); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Embedded_statementContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public Simple_embedded_statementContext simple_embedded_statement() { + return getRuleContext(Simple_embedded_statementContext.class,0); + } + public Embedded_statementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_embedded_statement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterEmbedded_statement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitEmbedded_statement(this); + } + } + + public final Embedded_statementContext embedded_statement() throws RecognitionException { + Embedded_statementContext _localctx = new Embedded_statementContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_embedded_statement); + try { + setState(1283); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1281); + block(); + } + break; + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BREAK: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case CONTINUE: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DO: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FIXED: + case FLOAT: + case FOR: + case FOREACH: + case FROM: + case GET: + case GOTO: + case GROUP: + case IF: + case INT: + case INTO: + case JOIN: + case LET: + case LOCK: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case RETURN: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case SWITCH: + case THIS: + case THROW: + case TRUE: + case TRY: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case UNSAFE: + case USHORT: + case USING: + case VAR: + case WHEN: + case WHERE: + case WHILE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case SEMICOLON: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 2); + { + setState(1282); + simple_embedded_statement(); + } + 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 Simple_embedded_statementContext extends ParserRuleContext { + public Simple_embedded_statementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simple_embedded_statement; } + + public Simple_embedded_statementContext() { } + public void copyFrom(Simple_embedded_statementContext ctx) { + super.copyFrom(ctx); + } + } + public static class TryStatementContext extends Simple_embedded_statementContext { + public TerminalNode TRY() { return getToken(CSharpParser.TRY, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public Catch_clausesContext catch_clauses() { + return getRuleContext(Catch_clausesContext.class,0); + } + public Finally_clauseContext finally_clause() { + return getRuleContext(Finally_clauseContext.class,0); + } + public TryStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterTryStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitTryStatement(this); + } + } + public static class CheckedStatementContext extends Simple_embedded_statementContext { + public TerminalNode CHECKED() { return getToken(CSharpParser.CHECKED, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public CheckedStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterCheckedStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitCheckedStatement(this); + } + } + public static class ThrowStatementContext extends Simple_embedded_statementContext { + public TerminalNode THROW() { return getToken(CSharpParser.THROW, 0); } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ThrowStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterThrowStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitThrowStatement(this); + } + } + public static class TheEmptyStatementContext extends Simple_embedded_statementContext { + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public TheEmptyStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterTheEmptyStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitTheEmptyStatement(this); + } + } + public static class UnsafeStatementContext extends Simple_embedded_statementContext { + public TerminalNode UNSAFE() { return getToken(CSharpParser.UNSAFE, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public UnsafeStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterUnsafeStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitUnsafeStatement(this); + } + } + public static class ForStatementContext extends Simple_embedded_statementContext { + public TerminalNode FOR() { return getToken(CSharpParser.FOR, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public List SEMICOLON() { return getTokens(CSharpParser.SEMICOLON); } + public TerminalNode SEMICOLON(int i) { + return getToken(CSharpParser.SEMICOLON, i); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class,0); + } + public For_initializerContext for_initializer() { + return getRuleContext(For_initializerContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public For_iteratorContext for_iterator() { + return getRuleContext(For_iteratorContext.class,0); + } + public ForStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterForStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitForStatement(this); + } + } + public static class BreakStatementContext extends Simple_embedded_statementContext { + public TerminalNode BREAK() { return getToken(CSharpParser.BREAK, 0); } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public BreakStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterBreakStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitBreakStatement(this); + } + } + public static class IfStatementContext extends Simple_embedded_statementContext { + public TerminalNode IF() { return getToken(CSharpParser.IF, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public List if_body() { + return getRuleContexts(If_bodyContext.class); + } + public If_bodyContext if_body(int i) { + return getRuleContext(If_bodyContext.class,i); + } + public TerminalNode ELSE() { return getToken(CSharpParser.ELSE, 0); } + public IfStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterIfStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitIfStatement(this); + } + } + public static class ReturnStatementContext extends Simple_embedded_statementContext { + public TerminalNode RETURN() { return getToken(CSharpParser.RETURN, 0); } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ReturnStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterReturnStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitReturnStatement(this); + } + } + public static class GotoStatementContext extends Simple_embedded_statementContext { + public TerminalNode GOTO() { return getToken(CSharpParser.GOTO, 0); } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode CASE() { return getToken(CSharpParser.CASE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(CSharpParser.DEFAULT, 0); } + public GotoStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterGotoStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitGotoStatement(this); + } + } + public static class SwitchStatementContext extends Simple_embedded_statementContext { + public TerminalNode SWITCH() { return getToken(CSharpParser.SWITCH, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public List switch_section() { + return getRuleContexts(Switch_sectionContext.class); + } + public Switch_sectionContext switch_section(int i) { + return getRuleContext(Switch_sectionContext.class,i); + } + public SwitchStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSwitchStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSwitchStatement(this); + } + } + public static class FixedStatementContext extends Simple_embedded_statementContext { + public TerminalNode FIXED() { return getToken(CSharpParser.FIXED, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public Pointer_typeContext pointer_type() { + return getRuleContext(Pointer_typeContext.class,0); + } + public Fixed_pointer_declaratorsContext fixed_pointer_declarators() { + return getRuleContext(Fixed_pointer_declaratorsContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class,0); + } + public FixedStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFixedStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFixedStatement(this); + } + } + public static class WhileStatementContext extends Simple_embedded_statementContext { + public TerminalNode WHILE() { return getToken(CSharpParser.WHILE, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class,0); + } + public WhileStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterWhileStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitWhileStatement(this); + } + } + public static class DoStatementContext extends Simple_embedded_statementContext { + public TerminalNode DO() { return getToken(CSharpParser.DO, 0); } + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class,0); + } + public TerminalNode WHILE() { return getToken(CSharpParser.WHILE, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public DoStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterDoStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitDoStatement(this); + } + } + public static class ForeachStatementContext extends Simple_embedded_statementContext { + public TerminalNode FOREACH() { return getToken(CSharpParser.FOREACH, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public Local_variable_typeContext local_variable_type() { + return getRuleContext(Local_variable_typeContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class,0); + } + public TerminalNode AWAIT() { return getToken(CSharpParser.AWAIT, 0); } + public ForeachStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterForeachStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitForeachStatement(this); + } + } + public static class UncheckedStatementContext extends Simple_embedded_statementContext { + public TerminalNode UNCHECKED() { return getToken(CSharpParser.UNCHECKED, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public UncheckedStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterUncheckedStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitUncheckedStatement(this); + } + } + public static class ExpressionStatementContext extends Simple_embedded_statementContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public ExpressionStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterExpressionStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitExpressionStatement(this); + } + } + public static class ContinueStatementContext extends Simple_embedded_statementContext { + public TerminalNode CONTINUE() { return getToken(CSharpParser.CONTINUE, 0); } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public ContinueStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterContinueStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitContinueStatement(this); + } + } + public static class UsingStatementContext extends Simple_embedded_statementContext { + public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public Resource_acquisitionContext resource_acquisition() { + return getRuleContext(Resource_acquisitionContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class,0); + } + public UsingStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterUsingStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitUsingStatement(this); + } + } + public static class LockStatementContext extends Simple_embedded_statementContext { + public TerminalNode LOCK() { return getToken(CSharpParser.LOCK, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class,0); + } + public LockStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLockStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLockStatement(this); + } + } + public static class YieldStatementContext extends Simple_embedded_statementContext { + public TerminalNode YIELD() { return getToken(CSharpParser.YIELD, 0); } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public TerminalNode RETURN() { return getToken(CSharpParser.RETURN, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode BREAK() { return getToken(CSharpParser.BREAK, 0); } + public YieldStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterYieldStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitYieldStatement(this); + } + } + + public final Simple_embedded_statementContext simple_embedded_statement() throws RecognitionException { + Simple_embedded_statementContext _localctx = new Simple_embedded_statementContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_simple_embedded_statement); + int _la; + try { + setState(1415); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { + case 1: + _localctx = new TheEmptyStatementContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1285); + match(SEMICOLON); + } + break; + case 2: + _localctx = new ExpressionStatementContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1286); + expression(); + setState(1287); + match(SEMICOLON); + } + break; + case 3: + _localctx = new IfStatementContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1289); + match(IF); + setState(1290); + match(OPEN_PARENS); + setState(1291); + expression(); + setState(1292); + match(CLOSE_PARENS); + setState(1293); + if_body(); + setState(1296); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { + case 1: + { + setState(1294); + match(ELSE); + setState(1295); + if_body(); + } + break; + } + } + break; + case 4: + _localctx = new SwitchStatementContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(1298); + match(SWITCH); + setState(1299); + match(OPEN_PARENS); + setState(1300); + expression(); + setState(1301); + match(CLOSE_PARENS); + setState(1302); + match(OPEN_BRACE); + setState(1306); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CASE || _la==DEFAULT) { + { + { + setState(1303); + switch_section(); + } + } + setState(1308); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1309); + match(CLOSE_BRACE); + } + break; + case 5: + _localctx = new WhileStatementContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(1311); + match(WHILE); + setState(1312); + match(OPEN_PARENS); + setState(1313); + expression(); + setState(1314); + match(CLOSE_PARENS); + setState(1315); + embedded_statement(); + } + break; + case 6: + _localctx = new DoStatementContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(1317); + match(DO); + setState(1318); + embedded_statement(); + setState(1319); + match(WHILE); + setState(1320); + match(OPEN_PARENS); + setState(1321); + expression(); + setState(1322); + match(CLOSE_PARENS); + setState(1323); + match(SEMICOLON); + } + break; + case 7: + _localctx = new ForStatementContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(1325); + match(FOR); + setState(1326); + match(OPEN_PARENS); + setState(1328); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FIXED) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (USING - 64)) | (1L << (VAR - 64)) | (1L << (VOID - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(1327); + for_initializer(); + } + } + + setState(1330); + match(SEMICOLON); + setState(1332); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(1331); + expression(); + } + } + + setState(1334); + match(SEMICOLON); + setState(1336); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(1335); + for_iterator(); + } + } + + setState(1338); + match(CLOSE_PARENS); + setState(1339); + embedded_statement(); + } + break; + case 8: + _localctx = new ForeachStatementContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(1341); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AWAIT) { + { + setState(1340); + match(AWAIT); + } + } + + setState(1343); + match(FOREACH); + setState(1344); + match(OPEN_PARENS); + setState(1345); + local_variable_type(); + setState(1346); + identifier(); + setState(1347); + match(IN); + setState(1348); + expression(); + setState(1349); + match(CLOSE_PARENS); + setState(1350); + embedded_statement(); + } + break; + case 9: + _localctx = new BreakStatementContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(1352); + match(BREAK); + setState(1353); + match(SEMICOLON); + } + break; + case 10: + _localctx = new ContinueStatementContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(1354); + match(CONTINUE); + setState(1355); + match(SEMICOLON); + } + break; + case 11: + _localctx = new GotoStatementContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(1356); + match(GOTO); + setState(1361); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BY: + case DESCENDING: + case DYNAMIC: + case EQUALS: + case FROM: + case GET: + case GROUP: + case INTO: + case JOIN: + case LET: + case NAMEOF: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SELECT: + case SET: + case UNMANAGED: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + { + setState(1357); + identifier(); + } + break; + case CASE: + { + setState(1358); + match(CASE); + setState(1359); + expression(); + } + break; + case DEFAULT: + { + setState(1360); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1363); + match(SEMICOLON); + } + break; + case 12: + _localctx = new ReturnStatementContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(1364); + match(RETURN); + setState(1366); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(1365); + expression(); + } + } + + setState(1368); + match(SEMICOLON); + } + break; + case 13: + _localctx = new ThrowStatementContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(1369); + match(THROW); + setState(1371); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(1370); + expression(); + } + } + + setState(1373); + match(SEMICOLON); + } + break; + case 14: + _localctx = new TryStatementContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(1374); + match(TRY); + setState(1375); + block(); + setState(1381); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CATCH: + { + setState(1376); + catch_clauses(); + setState(1378); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FINALLY) { + { + setState(1377); + finally_clause(); + } + } + + } + break; + case FINALLY: + { + setState(1380); + finally_clause(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 15: + _localctx = new CheckedStatementContext(_localctx); + enterOuterAlt(_localctx, 15); + { + setState(1383); + match(CHECKED); + setState(1384); + block(); + } + break; + case 16: + _localctx = new UncheckedStatementContext(_localctx); + enterOuterAlt(_localctx, 16); + { + setState(1385); + match(UNCHECKED); + setState(1386); + block(); + } + break; + case 17: + _localctx = new LockStatementContext(_localctx); + enterOuterAlt(_localctx, 17); + { + setState(1387); + match(LOCK); + setState(1388); + match(OPEN_PARENS); + setState(1389); + expression(); + setState(1390); + match(CLOSE_PARENS); + setState(1391); + embedded_statement(); + } + break; + case 18: + _localctx = new UsingStatementContext(_localctx); + enterOuterAlt(_localctx, 18); + { + setState(1393); + match(USING); + setState(1394); + match(OPEN_PARENS); + setState(1395); + resource_acquisition(); + setState(1396); + match(CLOSE_PARENS); + setState(1397); + embedded_statement(); + } + break; + case 19: + _localctx = new YieldStatementContext(_localctx); + enterOuterAlt(_localctx, 19); + { + setState(1399); + match(YIELD); + setState(1403); + _errHandler.sync(this); + switch (_input.LA(1)) { + case RETURN: + { + setState(1400); + match(RETURN); + setState(1401); + expression(); + } + break; + case BREAK: + { + setState(1402); + match(BREAK); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1405); + match(SEMICOLON); + } + break; + case 20: + _localctx = new UnsafeStatementContext(_localctx); + enterOuterAlt(_localctx, 20); + { + setState(1406); + match(UNSAFE); + setState(1407); + block(); + } + break; + case 21: + _localctx = new FixedStatementContext(_localctx); + enterOuterAlt(_localctx, 21); + { + setState(1408); + match(FIXED); + setState(1409); + match(OPEN_PARENS); + setState(1410); + pointer_type(); + setState(1411); + fixed_pointer_declarators(); + setState(1412); + match(CLOSE_PARENS); + setState(1413); + embedded_statement(); + } + break; + } + } + 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 TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public Statement_listContext statement_list() { + return getRuleContext(Statement_listContext.class,0); + } + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_block; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterBlock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitBlock(this); + } + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1417); + match(OPEN_BRACE); + setState(1419); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BREAK) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << CONST) | (1L << CONTINUE) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DO) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FIXED) | (1L << FLOAT) | (1L << FOR) | (1L << FOREACH) | (1L << FROM) | (1L << GET) | (1L << GOTO) | (1L << GROUP) | (1L << IF) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LOCK) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (RETURN - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STATIC - 64)) | (1L << (STRING - 64)) | (1L << (SWITCH - 64)) | (1L << (THIS - 64)) | (1L << (THROW - 64)) | (1L << (TRUE - 64)) | (1L << (TRY - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (UNSAFE - 64)) | (1L << (USHORT - 64)) | (1L << (USING - 64)) | (1L << (VAR - 64)) | (1L << (VOID - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (WHILE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)) | (1L << (OPEN_BRACE - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (SEMICOLON - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(1418); + statement_list(); + } + } + + setState(1421); + match(CLOSE_BRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Local_variable_declarationContext extends ParserRuleContext { + public Local_variable_typeContext local_variable_type() { + return getRuleContext(Local_variable_typeContext.class,0); + } + public List local_variable_declarator() { + return getRuleContexts(Local_variable_declaratorContext.class); + } + public Local_variable_declaratorContext local_variable_declarator(int i) { + return getRuleContext(Local_variable_declaratorContext.class,i); + } + public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } + public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } + public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public TerminalNode FIXED() { return getToken(CSharpParser.FIXED, 0); } + public Pointer_typeContext pointer_type() { + return getRuleContext(Pointer_typeContext.class,0); + } + public Fixed_pointer_declaratorsContext fixed_pointer_declarators() { + return getRuleContext(Fixed_pointer_declaratorsContext.class,0); + } + public Local_variable_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_local_variable_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLocal_variable_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLocal_variable_declaration(this); + } + } + + public final Local_variable_declarationContext local_variable_declaration() throws RecognitionException { + Local_variable_declarationContext _localctx = new Local_variable_declarationContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_local_variable_declaration); + int _la; + try { + setState(1442); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BOOL: + case BY: + case BYTE: + case CHAR: + case DECIMAL: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case STRING: + case UINT: + case ULONG: + case UNMANAGED: + case USHORT: + case USING: + case VAR: + case VOID: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case OPEN_PARENS: + enterOuterAlt(_localctx, 1); + { + setState(1427); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) { + case 1: + { + setState(1423); + match(USING); + } + break; + case 2: + { + setState(1424); + match(REF); + } + break; + case 3: + { + setState(1425); + match(REF); + setState(1426); + match(READONLY); + } + break; + } + setState(1429); + local_variable_type(); + setState(1430); + local_variable_declarator(); + setState(1435); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1431); + match(COMMA); + setState(1432); + local_variable_declarator(); + } + } + setState(1437); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case FIXED: + enterOuterAlt(_localctx, 2); + { + setState(1438); + match(FIXED); + setState(1439); + pointer_type(); + setState(1440); + fixed_pointer_declarators(); + } + 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 Local_variable_typeContext extends ParserRuleContext { + public TerminalNode VAR() { return getToken(CSharpParser.VAR, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public Local_variable_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_local_variable_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLocal_variable_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLocal_variable_type(this); + } + } + + public final Local_variable_typeContext local_variable_type() throws RecognitionException { + Local_variable_typeContext _localctx = new Local_variable_typeContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_local_variable_type); + try { + setState(1446); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1444); + match(VAR); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1445); + type_(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Local_variable_declaratorContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public Local_variable_initializerContext local_variable_initializer() { + return getRuleContext(Local_variable_initializerContext.class,0); + } + public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } + public Local_variable_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_local_variable_declarator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLocal_variable_declarator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLocal_variable_declarator(this); + } + } + + public final Local_variable_declaratorContext local_variable_declarator() throws RecognitionException { + Local_variable_declaratorContext _localctx = new Local_variable_declaratorContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_local_variable_declarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1448); + identifier(); + setState(1454); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGNMENT) { + { + setState(1449); + match(ASSIGNMENT); + setState(1451); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) { + case 1: + { + setState(1450); + match(REF); + } + break; + } + setState(1453); + local_variable_initializer(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Local_variable_initializerContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Array_initializerContext array_initializer() { + return getRuleContext(Array_initializerContext.class,0); + } + public Stackalloc_initializerContext stackalloc_initializer() { + return getRuleContext(Stackalloc_initializerContext.class,0); + } + public Local_variable_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_local_variable_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLocal_variable_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLocal_variable_initializer(this); + } + } + + public final Local_variable_initializerContext local_variable_initializer() throws RecognitionException { + Local_variable_initializerContext _localctx = new Local_variable_initializerContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_local_variable_initializer); + try { + setState(1459); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(1456); + expression(); + } + break; + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(1457); + array_initializer(); + } + break; + case STACKALLOC: + enterOuterAlt(_localctx, 3); + { + setState(1458); + stackalloc_initializer(); + } + 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 Local_constant_declarationContext extends ParserRuleContext { + public TerminalNode CONST() { return getToken(CSharpParser.CONST, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public Constant_declaratorsContext constant_declarators() { + return getRuleContext(Constant_declaratorsContext.class,0); + } + public Local_constant_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_local_constant_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLocal_constant_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLocal_constant_declaration(this); + } + } + + public final Local_constant_declarationContext local_constant_declaration() throws RecognitionException { + Local_constant_declarationContext _localctx = new Local_constant_declarationContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_local_constant_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1461); + match(CONST); + setState(1462); + type_(); + setState(1463); + constant_declarators(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class If_bodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public Simple_embedded_statementContext simple_embedded_statement() { + return getRuleContext(Simple_embedded_statementContext.class,0); + } + public If_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_if_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterIf_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitIf_body(this); + } + } + + public final If_bodyContext if_body() throws RecognitionException { + If_bodyContext _localctx = new If_bodyContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_if_body); + try { + setState(1467); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1465); + block(); + } + break; + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BREAK: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case CONTINUE: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DO: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FIXED: + case FLOAT: + case FOR: + case FOREACH: + case FROM: + case GET: + case GOTO: + case GROUP: + case IF: + case INT: + case INTO: + case JOIN: + case LET: + case LOCK: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case RETURN: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case SWITCH: + case THIS: + case THROW: + case TRUE: + case TRY: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case UNSAFE: + case USHORT: + case USING: + case VAR: + case WHEN: + case WHERE: + case WHILE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case SEMICOLON: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 2); + { + setState(1466); + simple_embedded_statement(); + } + 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 Switch_sectionContext extends ParserRuleContext { + public Statement_listContext statement_list() { + return getRuleContext(Statement_listContext.class,0); + } + public List switch_label() { + return getRuleContexts(Switch_labelContext.class); + } + public Switch_labelContext switch_label(int i) { + return getRuleContext(Switch_labelContext.class,i); + } + public Switch_sectionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switch_section; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSwitch_section(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSwitch_section(this); + } + } + + public final Switch_sectionContext switch_section() throws RecognitionException { + Switch_sectionContext _localctx = new Switch_sectionContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_switch_section); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1470); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1469); + switch_label(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1472); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,153,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(1474); + statement_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Switch_labelContext extends ParserRuleContext { + public TerminalNode CASE() { return getToken(CSharpParser.CASE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public Case_guardContext case_guard() { + return getRuleContext(Case_guardContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(CSharpParser.DEFAULT, 0); } + public Switch_labelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switch_label; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSwitch_label(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSwitch_label(this); + } + } + + public final Switch_labelContext switch_label() throws RecognitionException { + Switch_labelContext _localctx = new Switch_labelContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_switch_label); + int _la; + try { + setState(1485); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CASE: + enterOuterAlt(_localctx, 1); + { + setState(1476); + match(CASE); + setState(1477); + expression(); + setState(1479); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHEN) { + { + setState(1478); + case_guard(); + } + } + + setState(1481); + match(COLON); + } + break; + case DEFAULT: + enterOuterAlt(_localctx, 2); + { + setState(1483); + match(DEFAULT); + setState(1484); + match(COLON); + } + 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 Case_guardContext extends ParserRuleContext { + public TerminalNode WHEN() { return getToken(CSharpParser.WHEN, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Case_guardContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_case_guard; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterCase_guard(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitCase_guard(this); + } + } + + public final Case_guardContext case_guard() throws RecognitionException { + Case_guardContext _localctx = new Case_guardContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_case_guard); + try { + enterOuterAlt(_localctx, 1); + { + setState(1487); + match(WHEN); + setState(1488); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Statement_listContext extends ParserRuleContext { + public List statement() { + return getRuleContexts(StatementContext.class); + } + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class,i); + } + public Statement_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterStatement_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitStatement_list(this); + } + } + + public final Statement_listContext statement_list() throws RecognitionException { + Statement_listContext _localctx = new Statement_listContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_statement_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1491); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1490); + statement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1493); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,156,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class For_initializerContext extends ParserRuleContext { + public Local_variable_declarationContext local_variable_declaration() { + return getRuleContext(Local_variable_declarationContext.class,0); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public For_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_for_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFor_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFor_initializer(this); + } + } + + public final For_initializerContext for_initializer() throws RecognitionException { + For_initializerContext _localctx = new For_initializerContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_for_initializer); + int _la; + try { + setState(1504); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1495); + local_variable_declaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1496); + expression(); + setState(1501); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1497); + match(COMMA); + setState(1498); + expression(); + } + } + setState(1503); + _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 For_iteratorContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public For_iteratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_for_iterator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFor_iterator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFor_iterator(this); + } + } + + public final For_iteratorContext for_iterator() throws RecognitionException { + For_iteratorContext _localctx = new For_iteratorContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_for_iterator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1506); + expression(); + setState(1511); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1507); + match(COMMA); + setState(1508); + expression(); + } + } + setState(1513); + _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 Catch_clausesContext extends ParserRuleContext { + public List specific_catch_clause() { + return getRuleContexts(Specific_catch_clauseContext.class); + } + public Specific_catch_clauseContext specific_catch_clause(int i) { + return getRuleContext(Specific_catch_clauseContext.class,i); + } + public General_catch_clauseContext general_catch_clause() { + return getRuleContext(General_catch_clauseContext.class,0); + } + public Catch_clausesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catch_clauses; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterCatch_clauses(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitCatch_clauses(this); + } + } + + public final Catch_clausesContext catch_clauses() throws RecognitionException { + Catch_clausesContext _localctx = new Catch_clausesContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_catch_clauses); + int _la; + try { + int _alt; + setState(1525); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1514); + specific_catch_clause(); + setState(1518); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,160,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1515); + specific_catch_clause(); + } + } + } + setState(1520); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,160,_ctx); + } + setState(1522); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CATCH) { + { + setState(1521); + general_catch_clause(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1524); + general_catch_clause(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Specific_catch_clauseContext extends ParserRuleContext { + public TerminalNode CATCH() { return getToken(CSharpParser.CATCH, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public Class_typeContext class_type() { + return getRuleContext(Class_typeContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Exception_filterContext exception_filter() { + return getRuleContext(Exception_filterContext.class,0); + } + public Specific_catch_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_specific_catch_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSpecific_catch_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSpecific_catch_clause(this); + } + } + + public final Specific_catch_clauseContext specific_catch_clause() throws RecognitionException { + Specific_catch_clauseContext _localctx = new Specific_catch_clauseContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_specific_catch_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1527); + match(CATCH); + setState(1528); + match(OPEN_PARENS); + setState(1529); + class_type(); + setState(1531); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)))) != 0)) { + { + setState(1530); + identifier(); + } + } + + setState(1533); + match(CLOSE_PARENS); + setState(1535); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHEN) { + { + setState(1534); + exception_filter(); + } + } + + setState(1537); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class General_catch_clauseContext extends ParserRuleContext { + public TerminalNode CATCH() { return getToken(CSharpParser.CATCH, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public Exception_filterContext exception_filter() { + return getRuleContext(Exception_filterContext.class,0); + } + public General_catch_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_general_catch_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterGeneral_catch_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitGeneral_catch_clause(this); + } + } + + public final General_catch_clauseContext general_catch_clause() throws RecognitionException { + General_catch_clauseContext _localctx = new General_catch_clauseContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_general_catch_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1539); + match(CATCH); + setState(1541); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHEN) { + { + setState(1540); + exception_filter(); + } + } + + setState(1543); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Exception_filterContext extends ParserRuleContext { + public TerminalNode WHEN() { return getToken(CSharpParser.WHEN, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Exception_filterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exception_filter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterException_filter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitException_filter(this); + } + } + + public final Exception_filterContext exception_filter() throws RecognitionException { + Exception_filterContext _localctx = new Exception_filterContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_exception_filter); + try { + enterOuterAlt(_localctx, 1); + { + setState(1545); + match(WHEN); + setState(1546); + match(OPEN_PARENS); + setState(1547); + expression(); + setState(1548); + match(CLOSE_PARENS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Finally_clauseContext extends ParserRuleContext { + public TerminalNode FINALLY() { return getToken(CSharpParser.FINALLY, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public Finally_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_finally_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFinally_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFinally_clause(this); + } + } + + public final Finally_clauseContext finally_clause() throws RecognitionException { + Finally_clauseContext _localctx = new Finally_clauseContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_finally_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1550); + match(FINALLY); + setState(1551); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Resource_acquisitionContext extends ParserRuleContext { + public Local_variable_declarationContext local_variable_declaration() { + return getRuleContext(Local_variable_declarationContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Resource_acquisitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resource_acquisition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterResource_acquisition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitResource_acquisition(this); + } + } + + public final Resource_acquisitionContext resource_acquisition() throws RecognitionException { + Resource_acquisitionContext _localctx = new Resource_acquisitionContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_resource_acquisition); + try { + setState(1555); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1553); + local_variable_declaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1554); + expression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Namespace_declarationContext extends ParserRuleContext { + public Qualified_identifierContext qi; + public TerminalNode NAMESPACE() { return getToken(CSharpParser.NAMESPACE, 0); } + public Namespace_bodyContext namespace_body() { + return getRuleContext(Namespace_bodyContext.class,0); + } + public Qualified_identifierContext qualified_identifier() { + return getRuleContext(Qualified_identifierContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Namespace_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespace_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterNamespace_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitNamespace_declaration(this); + } + } + + public final Namespace_declarationContext namespace_declaration() throws RecognitionException { + Namespace_declarationContext _localctx = new Namespace_declarationContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_namespace_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1557); + match(NAMESPACE); + setState(1558); + ((Namespace_declarationContext)_localctx).qi = qualified_identifier(); + setState(1559); + namespace_body(); + setState(1561); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEMICOLON) { + { + setState(1560); + match(SEMICOLON); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Qualified_identifierContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public List DOT() { return getTokens(CSharpParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(CSharpParser.DOT, i); + } + public Qualified_identifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualified_identifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterQualified_identifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitQualified_identifier(this); + } + } + + public final Qualified_identifierContext qualified_identifier() throws RecognitionException { + Qualified_identifierContext _localctx = new Qualified_identifierContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_qualified_identifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1563); + identifier(); + setState(1568); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(1564); + match(DOT); + setState(1565); + identifier(); + } + } + setState(1570); + _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 Namespace_bodyContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public Extern_alias_directivesContext extern_alias_directives() { + return getRuleContext(Extern_alias_directivesContext.class,0); + } + public Using_directivesContext using_directives() { + return getRuleContext(Using_directivesContext.class,0); + } + public Namespace_member_declarationsContext namespace_member_declarations() { + return getRuleContext(Namespace_member_declarationsContext.class,0); + } + public Namespace_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespace_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterNamespace_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitNamespace_body(this); + } + } + + public final Namespace_bodyContext namespace_body() throws RecognitionException { + Namespace_bodyContext _localctx = new Namespace_bodyContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_namespace_body); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1571); + match(OPEN_BRACE); + setState(1573); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { + case 1: + { + setState(1572); + extern_alias_directives(); + } + break; + } + setState(1576); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(1575); + using_directives(); + } + } + + setState(1579); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASYNC) | (1L << CLASS) | (1L << DELEGATE) | (1L << ENUM) | (1L << EXTERN) | (1L << INTERFACE) | (1L << INTERNAL))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (NAMESPACE - 65)) | (1L << (NEW - 65)) | (1L << (OVERRIDE - 65)) | (1L << (PARTIAL - 65)) | (1L << (PRIVATE - 65)) | (1L << (PROTECTED - 65)) | (1L << (PUBLIC - 65)) | (1L << (READONLY - 65)) | (1L << (REF - 65)) | (1L << (SEALED - 65)) | (1L << (STATIC - 65)) | (1L << (STRUCT - 65)) | (1L << (UNSAFE - 65)) | (1L << (VIRTUAL - 65)) | (1L << (VOLATILE - 65)) | (1L << (OPEN_BRACKET - 65)))) != 0)) { + { + setState(1578); + namespace_member_declarations(); + } + } + + setState(1581); + match(CLOSE_BRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Extern_alias_directivesContext extends ParserRuleContext { + public List extern_alias_directive() { + return getRuleContexts(Extern_alias_directiveContext.class); + } + public Extern_alias_directiveContext extern_alias_directive(int i) { + return getRuleContext(Extern_alias_directiveContext.class,i); + } + public Extern_alias_directivesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_extern_alias_directives; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterExtern_alias_directives(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitExtern_alias_directives(this); + } + } + + public final Extern_alias_directivesContext extern_alias_directives() throws RecognitionException { + Extern_alias_directivesContext _localctx = new Extern_alias_directivesContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_extern_alias_directives); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1584); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1583); + extern_alias_directive(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1586); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,172,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Extern_alias_directiveContext extends ParserRuleContext { + public TerminalNode EXTERN() { return getToken(CSharpParser.EXTERN, 0); } + public TerminalNode ALIAS() { return getToken(CSharpParser.ALIAS, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Extern_alias_directiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_extern_alias_directive; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterExtern_alias_directive(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitExtern_alias_directive(this); + } + } + + public final Extern_alias_directiveContext extern_alias_directive() throws RecognitionException { + Extern_alias_directiveContext _localctx = new Extern_alias_directiveContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_extern_alias_directive); + try { + enterOuterAlt(_localctx, 1); + { + setState(1588); + match(EXTERN); + setState(1589); + match(ALIAS); + setState(1590); + identifier(); + setState(1591); + match(SEMICOLON); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Using_directivesContext extends ParserRuleContext { + public List using_directive() { + return getRuleContexts(Using_directiveContext.class); + } + public Using_directiveContext using_directive(int i) { + return getRuleContext(Using_directiveContext.class,i); + } + public Using_directivesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_using_directives; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterUsing_directives(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitUsing_directives(this); + } + } + + public final Using_directivesContext using_directives() throws RecognitionException { + Using_directivesContext _localctx = new Using_directivesContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_using_directives); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1594); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1593); + using_directive(); + } + } + setState(1596); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==USING ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Using_directiveContext extends ParserRuleContext { + public Using_directiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_using_directive; } + + public Using_directiveContext() { } + public void copyFrom(Using_directiveContext ctx) { + super.copyFrom(ctx); + } + } + public static class UsingAliasDirectiveContext extends Using_directiveContext { + public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public UsingAliasDirectiveContext(Using_directiveContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterUsingAliasDirective(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitUsingAliasDirective(this); + } + } + public static class UsingNamespaceDirectiveContext extends Using_directiveContext { + public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public UsingNamespaceDirectiveContext(Using_directiveContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterUsingNamespaceDirective(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitUsingNamespaceDirective(this); + } + } + public static class UsingStaticDirectiveContext extends Using_directiveContext { + public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } + public TerminalNode STATIC() { return getToken(CSharpParser.STATIC, 0); } + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public UsingStaticDirectiveContext(Using_directiveContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterUsingStaticDirective(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitUsingStaticDirective(this); + } + } + + public final Using_directiveContext using_directive() throws RecognitionException { + Using_directiveContext _localctx = new Using_directiveContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_using_directive); + try { + setState(1613); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) { + case 1: + _localctx = new UsingAliasDirectiveContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1598); + match(USING); + setState(1599); + identifier(); + setState(1600); + match(ASSIGNMENT); + setState(1601); + namespace_or_type_name(); + setState(1602); + match(SEMICOLON); + } + break; + case 2: + _localctx = new UsingNamespaceDirectiveContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1604); + match(USING); + setState(1605); + namespace_or_type_name(); + setState(1606); + match(SEMICOLON); + } + break; + case 3: + _localctx = new UsingStaticDirectiveContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1608); + match(USING); + setState(1609); + match(STATIC); + setState(1610); + namespace_or_type_name(); + setState(1611); + match(SEMICOLON); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Namespace_member_declarationsContext extends ParserRuleContext { + public List namespace_member_declaration() { + return getRuleContexts(Namespace_member_declarationContext.class); + } + public Namespace_member_declarationContext namespace_member_declaration(int i) { + return getRuleContext(Namespace_member_declarationContext.class,i); + } + public Namespace_member_declarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespace_member_declarations; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterNamespace_member_declarations(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitNamespace_member_declarations(this); + } + } + + public final Namespace_member_declarationsContext namespace_member_declarations() throws RecognitionException { + Namespace_member_declarationsContext _localctx = new Namespace_member_declarationsContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_namespace_member_declarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1616); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1615); + namespace_member_declaration(); + } + } + setState(1618); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASYNC) | (1L << CLASS) | (1L << DELEGATE) | (1L << ENUM) | (1L << EXTERN) | (1L << INTERFACE) | (1L << INTERNAL))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (NAMESPACE - 65)) | (1L << (NEW - 65)) | (1L << (OVERRIDE - 65)) | (1L << (PARTIAL - 65)) | (1L << (PRIVATE - 65)) | (1L << (PROTECTED - 65)) | (1L << (PUBLIC - 65)) | (1L << (READONLY - 65)) | (1L << (REF - 65)) | (1L << (SEALED - 65)) | (1L << (STATIC - 65)) | (1L << (STRUCT - 65)) | (1L << (UNSAFE - 65)) | (1L << (VIRTUAL - 65)) | (1L << (VOLATILE - 65)) | (1L << (OPEN_BRACKET - 65)))) != 0) ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Namespace_member_declarationContext extends ParserRuleContext { + public Namespace_declarationContext namespace_declaration() { + return getRuleContext(Namespace_declarationContext.class,0); + } + public Type_declarationContext type_declaration() { + return getRuleContext(Type_declarationContext.class,0); + } + public Namespace_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespace_member_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterNamespace_member_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitNamespace_member_declaration(this); + } + } + + public final Namespace_member_declarationContext namespace_member_declaration() throws RecognitionException { + Namespace_member_declarationContext _localctx = new Namespace_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_namespace_member_declaration); + try { + setState(1622); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NAMESPACE: + enterOuterAlt(_localctx, 1); + { + setState(1620); + namespace_declaration(); + } + break; + case ABSTRACT: + case ASYNC: + case CLASS: + case DELEGATE: + case ENUM: + case EXTERN: + case INTERFACE: + case INTERNAL: + case NEW: + case OVERRIDE: + case PARTIAL: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case READONLY: + case REF: + case SEALED: + case STATIC: + case STRUCT: + case UNSAFE: + case VIRTUAL: + case VOLATILE: + case OPEN_BRACKET: + enterOuterAlt(_localctx, 2); + { + setState(1621); + type_declaration(); + } + 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 Type_declarationContext extends ParserRuleContext { + public Class_definitionContext class_definition() { + return getRuleContext(Class_definitionContext.class,0); + } + public Struct_definitionContext struct_definition() { + return getRuleContext(Struct_definitionContext.class,0); + } + public Interface_definitionContext interface_definition() { + return getRuleContext(Interface_definitionContext.class,0); + } + public Enum_definitionContext enum_definition() { + return getRuleContext(Enum_definitionContext.class,0); + } + public Delegate_definitionContext delegate_definition() { + return getRuleContext(Delegate_definitionContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public All_member_modifiersContext all_member_modifiers() { + return getRuleContext(All_member_modifiersContext.class,0); + } + public Type_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterType_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitType_declaration(this); + } + } + + public final Type_declarationContext type_declaration() throws RecognitionException { + Type_declarationContext _localctx = new Type_declarationContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_type_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1625); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1624); + attributes(); + } + } + + setState(1628); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) { + case 1: + { + setState(1627); + all_member_modifiers(); + } + break; + } + setState(1635); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CLASS: + { + setState(1630); + class_definition(); + } + break; + case READONLY: + case REF: + case STRUCT: + { + setState(1631); + struct_definition(); + } + break; + case INTERFACE: + { + setState(1632); + interface_definition(); + } + break; + case ENUM: + { + setState(1633); + enum_definition(); + } + break; + case DELEGATE: + { + setState(1634); + delegate_definition(); + } + 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 Qualified_alias_memberContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public TerminalNode DOUBLE_COLON() { return getToken(CSharpParser.DOUBLE_COLON, 0); } + public Type_argument_listContext type_argument_list() { + return getRuleContext(Type_argument_listContext.class,0); + } + public Qualified_alias_memberContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualified_alias_member; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterQualified_alias_member(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitQualified_alias_member(this); + } + } + + public final Qualified_alias_memberContext qualified_alias_member() throws RecognitionException { + Qualified_alias_memberContext _localctx = new Qualified_alias_memberContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_qualified_alias_member); + try { + enterOuterAlt(_localctx, 1); + { + setState(1637); + identifier(); + setState(1638); + match(DOUBLE_COLON); + setState(1639); + identifier(); + setState(1641); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) { + case 1: + { + setState(1640); + type_argument_list(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Type_parameter_listContext extends ParserRuleContext { + public TerminalNode LT() { return getToken(CSharpParser.LT, 0); } + public List type_parameter() { + return getRuleContexts(Type_parameterContext.class); + } + public Type_parameterContext type_parameter(int i) { + return getRuleContext(Type_parameterContext.class,i); + } + public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Type_parameter_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_parameter_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterType_parameter_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitType_parameter_list(this); + } + } + + public final Type_parameter_listContext type_parameter_list() throws RecognitionException { + Type_parameter_listContext _localctx = new Type_parameter_listContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_type_parameter_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1643); + match(LT); + setState(1644); + type_parameter(); + setState(1649); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1645); + match(COMMA); + setState(1646); + type_parameter(); + } + } + setState(1651); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1652); + match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Type_parameterContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public Type_parameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_parameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterType_parameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitType_parameter(this); + } + } + + public final Type_parameterContext type_parameter() throws RecognitionException { + Type_parameterContext _localctx = new Type_parameterContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_type_parameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1655); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1654); + attributes(); + } + } + + setState(1657); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Class_baseContext extends ParserRuleContext { + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public Class_typeContext class_type() { + return getRuleContext(Class_typeContext.class,0); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public List namespace_or_type_name() { + return getRuleContexts(Namespace_or_type_nameContext.class); + } + public Namespace_or_type_nameContext namespace_or_type_name(int i) { + return getRuleContext(Namespace_or_type_nameContext.class,i); + } + public Class_baseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_class_base; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterClass_base(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitClass_base(this); + } + } + + public final Class_baseContext class_base() throws RecognitionException { + Class_baseContext _localctx = new Class_baseContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_class_base); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1659); + match(COLON); + setState(1660); + class_type(); + setState(1665); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1661); + match(COMMA); + setState(1662); + namespace_or_type_name(); + } + } + setState(1667); + _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 Interface_type_listContext extends ParserRuleContext { + public List namespace_or_type_name() { + return getRuleContexts(Namespace_or_type_nameContext.class); + } + public Namespace_or_type_nameContext namespace_or_type_name(int i) { + return getRuleContext(Namespace_or_type_nameContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Interface_type_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interface_type_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInterface_type_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInterface_type_list(this); + } + } + + public final Interface_type_listContext interface_type_list() throws RecognitionException { + Interface_type_listContext _localctx = new Interface_type_listContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_interface_type_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1668); + namespace_or_type_name(); + setState(1673); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1669); + match(COMMA); + setState(1670); + namespace_or_type_name(); + } + } + setState(1675); + _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 Type_parameter_constraints_clausesContext extends ParserRuleContext { + public List type_parameter_constraints_clause() { + return getRuleContexts(Type_parameter_constraints_clauseContext.class); + } + public Type_parameter_constraints_clauseContext type_parameter_constraints_clause(int i) { + return getRuleContext(Type_parameter_constraints_clauseContext.class,i); + } + public Type_parameter_constraints_clausesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_parameter_constraints_clauses; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterType_parameter_constraints_clauses(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitType_parameter_constraints_clauses(this); + } + } + + public final Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() throws RecognitionException { + Type_parameter_constraints_clausesContext _localctx = new Type_parameter_constraints_clausesContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_type_parameter_constraints_clauses); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1677); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1676); + type_parameter_constraints_clause(); + } + } + setState(1679); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==WHERE ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Type_parameter_constraints_clauseContext extends ParserRuleContext { + public TerminalNode WHERE() { return getToken(CSharpParser.WHERE, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public Type_parameter_constraintsContext type_parameter_constraints() { + return getRuleContext(Type_parameter_constraintsContext.class,0); + } + public Type_parameter_constraints_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_parameter_constraints_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterType_parameter_constraints_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitType_parameter_constraints_clause(this); + } + } + + public final Type_parameter_constraints_clauseContext type_parameter_constraints_clause() throws RecognitionException { + Type_parameter_constraints_clauseContext _localctx = new Type_parameter_constraints_clauseContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_type_parameter_constraints_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1681); + match(WHERE); + setState(1682); + identifier(); + setState(1683); + match(COLON); + setState(1684); + type_parameter_constraints(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Type_parameter_constraintsContext extends ParserRuleContext { + public Constructor_constraintContext constructor_constraint() { + return getRuleContext(Constructor_constraintContext.class,0); + } + public Primary_constraintContext primary_constraint() { + return getRuleContext(Primary_constraintContext.class,0); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Secondary_constraintsContext secondary_constraints() { + return getRuleContext(Secondary_constraintsContext.class,0); + } + public Type_parameter_constraintsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_parameter_constraints; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterType_parameter_constraints(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitType_parameter_constraints(this); + } + } + + public final Type_parameter_constraintsContext type_parameter_constraints() throws RecognitionException { + Type_parameter_constraintsContext _localctx = new Type_parameter_constraintsContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_type_parameter_constraints); + int _la; + try { + setState(1696); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NEW: + enterOuterAlt(_localctx, 1); + { + setState(1686); + constructor_constraint(); + } + break; + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BY: + case CLASS: + case DESCENDING: + case DYNAMIC: + case EQUALS: + case FROM: + case GET: + case GROUP: + case INTO: + case JOIN: + case LET: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SELECT: + case SET: + case STRING: + case STRUCT: + case UNMANAGED: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(1687); + primary_constraint(); + setState(1690); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) { + case 1: + { + setState(1688); + match(COMMA); + setState(1689); + secondary_constraints(); + } + break; + } + setState(1694); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1692); + match(COMMA); + setState(1693); + constructor_constraint(); + } + } + + } + 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 Primary_constraintContext extends ParserRuleContext { + public Class_typeContext class_type() { + return getRuleContext(Class_typeContext.class,0); + } + public TerminalNode CLASS() { return getToken(CSharpParser.CLASS, 0); } + public TerminalNode INTERR() { return getToken(CSharpParser.INTERR, 0); } + public TerminalNode STRUCT() { return getToken(CSharpParser.STRUCT, 0); } + public TerminalNode UNMANAGED() { return getToken(CSharpParser.UNMANAGED, 0); } + public Primary_constraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primary_constraint; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterPrimary_constraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitPrimary_constraint(this); + } + } + + public final Primary_constraintContext primary_constraint() throws RecognitionException { + Primary_constraintContext _localctx = new Primary_constraintContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_primary_constraint); + int _la; + try { + setState(1705); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1698); + class_type(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1699); + match(CLASS); + setState(1701); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTERR) { + { + setState(1700); + match(INTERR); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1703); + match(STRUCT); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1704); + match(UNMANAGED); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Secondary_constraintsContext extends ParserRuleContext { + public List namespace_or_type_name() { + return getRuleContexts(Namespace_or_type_nameContext.class); + } + public Namespace_or_type_nameContext namespace_or_type_name(int i) { + return getRuleContext(Namespace_or_type_nameContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Secondary_constraintsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_secondary_constraints; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSecondary_constraints(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSecondary_constraints(this); + } + } + + public final Secondary_constraintsContext secondary_constraints() throws RecognitionException { + Secondary_constraintsContext _localctx = new Secondary_constraintsContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_secondary_constraints); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1707); + namespace_or_type_name(); + setState(1712); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,191,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1708); + match(COMMA); + setState(1709); + namespace_or_type_name(); + } + } + } + setState(1714); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,191,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Constructor_constraintContext extends ParserRuleContext { + public TerminalNode NEW() { return getToken(CSharpParser.NEW, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Constructor_constraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructor_constraint; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterConstructor_constraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitConstructor_constraint(this); + } + } + + public final Constructor_constraintContext constructor_constraint() throws RecognitionException { + Constructor_constraintContext _localctx = new Constructor_constraintContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_constructor_constraint); + try { + enterOuterAlt(_localctx, 1); + { + setState(1715); + match(NEW); + setState(1716); + match(OPEN_PARENS); + setState(1717); + match(CLOSE_PARENS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Class_bodyContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public Class_member_declarationsContext class_member_declarations() { + return getRuleContext(Class_member_declarationsContext.class,0); + } + public Class_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_class_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterClass_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitClass_body(this); + } + } + + public final Class_bodyContext class_body() throws RecognitionException { + Class_bodyContext _localctx = new Class_bodyContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_class_body); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1719); + match(OPEN_BRACE); + setState(1721); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONST) | (1L << DECIMAL) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << ENUM) | (1L << EQUALS) | (1L << EVENT) | (1L << EXPLICIT) | (1L << EXTERN) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << IMPLICIT) | (1L << INT) | (1L << INTERFACE) | (1L << INTERNAL) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (OVERRIDE - 64)) | (1L << (PARTIAL - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (PUBLIC - 64)) | (1L << (READONLY - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SEALED - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (STATIC - 64)) | (1L << (STRING - 64)) | (1L << (STRUCT - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNMANAGED - 64)) | (1L << (UNSAFE - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (VIRTUAL - 64)) | (1L << (VOID - 64)) | (1L << (VOLATILE - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (OPEN_BRACKET - 64)))) != 0) || _la==OPEN_PARENS || _la==TILDE) { + { + setState(1720); + class_member_declarations(); + } + } + + setState(1723); + match(CLOSE_BRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Class_member_declarationsContext extends ParserRuleContext { + public List class_member_declaration() { + return getRuleContexts(Class_member_declarationContext.class); + } + public Class_member_declarationContext class_member_declaration(int i) { + return getRuleContext(Class_member_declarationContext.class,i); + } + public Class_member_declarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_class_member_declarations; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterClass_member_declarations(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitClass_member_declarations(this); + } + } + + public final Class_member_declarationsContext class_member_declarations() throws RecognitionException { + Class_member_declarationsContext _localctx = new Class_member_declarationsContext(_ctx, getState()); + enterRule(_localctx, 252, RULE_class_member_declarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1726); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1725); + class_member_declaration(); + } + } + setState(1728); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONST) | (1L << DECIMAL) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << ENUM) | (1L << EQUALS) | (1L << EVENT) | (1L << EXPLICIT) | (1L << EXTERN) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << IMPLICIT) | (1L << INT) | (1L << INTERFACE) | (1L << INTERNAL) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (OVERRIDE - 64)) | (1L << (PARTIAL - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (PUBLIC - 64)) | (1L << (READONLY - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SEALED - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (STATIC - 64)) | (1L << (STRING - 64)) | (1L << (STRUCT - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNMANAGED - 64)) | (1L << (UNSAFE - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (VIRTUAL - 64)) | (1L << (VOID - 64)) | (1L << (VOLATILE - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (OPEN_BRACKET - 64)))) != 0) || _la==OPEN_PARENS || _la==TILDE ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Class_member_declarationContext extends ParserRuleContext { + public Common_member_declarationContext common_member_declaration() { + return getRuleContext(Common_member_declarationContext.class,0); + } + public Destructor_definitionContext destructor_definition() { + return getRuleContext(Destructor_definitionContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public All_member_modifiersContext all_member_modifiers() { + return getRuleContext(All_member_modifiersContext.class,0); + } + public Class_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_class_member_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterClass_member_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitClass_member_declaration(this); + } + } + + public final Class_member_declarationContext class_member_declaration() throws RecognitionException { + Class_member_declarationContext _localctx = new Class_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 254, RULE_class_member_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1731); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1730); + attributes(); + } + } + + setState(1734); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) { + case 1: + { + setState(1733); + all_member_modifiers(); + } + break; + } + setState(1738); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CLASS: + case CONST: + case DECIMAL: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case ENUM: + case EQUALS: + case EVENT: + case EXPLICIT: + case FLOAT: + case FROM: + case GET: + case GROUP: + case IMPLICIT: + case INT: + case INTERFACE: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case READONLY: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case STRING: + case STRUCT: + case UINT: + case ULONG: + case UNMANAGED: + case USHORT: + case VAR: + case VOID: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case OPEN_PARENS: + { + setState(1736); + common_member_declaration(); + } + break; + case TILDE: + { + setState(1737); + destructor_definition(); + } + 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 All_member_modifiersContext extends ParserRuleContext { + public List all_member_modifier() { + return getRuleContexts(All_member_modifierContext.class); + } + public All_member_modifierContext all_member_modifier(int i) { + return getRuleContext(All_member_modifierContext.class,i); + } + public All_member_modifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_all_member_modifiers; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAll_member_modifiers(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAll_member_modifiers(this); + } + } + + public final All_member_modifiersContext all_member_modifiers() throws RecognitionException { + All_member_modifiersContext _localctx = new All_member_modifiersContext(_ctx, getState()); + enterRule(_localctx, 256, RULE_all_member_modifiers); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1741); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1740); + all_member_modifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1743); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,197,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class All_member_modifierContext extends ParserRuleContext { + public TerminalNode NEW() { return getToken(CSharpParser.NEW, 0); } + public TerminalNode PUBLIC() { return getToken(CSharpParser.PUBLIC, 0); } + public TerminalNode PROTECTED() { return getToken(CSharpParser.PROTECTED, 0); } + public TerminalNode INTERNAL() { return getToken(CSharpParser.INTERNAL, 0); } + public TerminalNode PRIVATE() { return getToken(CSharpParser.PRIVATE, 0); } + public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } + public TerminalNode VOLATILE() { return getToken(CSharpParser.VOLATILE, 0); } + public TerminalNode VIRTUAL() { return getToken(CSharpParser.VIRTUAL, 0); } + public TerminalNode SEALED() { return getToken(CSharpParser.SEALED, 0); } + public TerminalNode OVERRIDE() { return getToken(CSharpParser.OVERRIDE, 0); } + public TerminalNode ABSTRACT() { return getToken(CSharpParser.ABSTRACT, 0); } + public TerminalNode STATIC() { return getToken(CSharpParser.STATIC, 0); } + public TerminalNode UNSAFE() { return getToken(CSharpParser.UNSAFE, 0); } + public TerminalNode EXTERN() { return getToken(CSharpParser.EXTERN, 0); } + public TerminalNode PARTIAL() { return getToken(CSharpParser.PARTIAL, 0); } + public TerminalNode ASYNC() { return getToken(CSharpParser.ASYNC, 0); } + public All_member_modifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_all_member_modifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAll_member_modifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAll_member_modifier(this); + } + } + + public final All_member_modifierContext all_member_modifier() throws RecognitionException { + All_member_modifierContext _localctx = new All_member_modifierContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_all_member_modifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1745); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASYNC) | (1L << EXTERN) | (1L << INTERNAL))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (NEW - 66)) | (1L << (OVERRIDE - 66)) | (1L << (PARTIAL - 66)) | (1L << (PRIVATE - 66)) | (1L << (PROTECTED - 66)) | (1L << (PUBLIC - 66)) | (1L << (READONLY - 66)) | (1L << (SEALED - 66)) | (1L << (STATIC - 66)) | (1L << (UNSAFE - 66)) | (1L << (VIRTUAL - 66)) | (1L << (VOLATILE - 66)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Common_member_declarationContext extends ParserRuleContext { + public Constant_declarationContext constant_declaration() { + return getRuleContext(Constant_declarationContext.class,0); + } + public Typed_member_declarationContext typed_member_declaration() { + return getRuleContext(Typed_member_declarationContext.class,0); + } + public Event_declarationContext event_declaration() { + return getRuleContext(Event_declarationContext.class,0); + } + public Conversion_operator_declaratorContext conversion_operator_declarator() { + return getRuleContext(Conversion_operator_declaratorContext.class,0); + } + public BodyContext body() { + return getRuleContext(BodyContext.class,0); + } + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class,0); + } + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Constructor_declarationContext constructor_declaration() { + return getRuleContext(Constructor_declarationContext.class,0); + } + public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } + public Method_declarationContext method_declaration() { + return getRuleContext(Method_declarationContext.class,0); + } + public Class_definitionContext class_definition() { + return getRuleContext(Class_definitionContext.class,0); + } + public Struct_definitionContext struct_definition() { + return getRuleContext(Struct_definitionContext.class,0); + } + public Interface_definitionContext interface_definition() { + return getRuleContext(Interface_definitionContext.class,0); + } + public Enum_definitionContext enum_definition() { + return getRuleContext(Enum_definitionContext.class,0); + } + public Delegate_definitionContext delegate_definition() { + return getRuleContext(Delegate_definitionContext.class,0); + } + public Common_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_common_member_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterCommon_member_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitCommon_member_declaration(this); + } + } + + public final Common_member_declarationContext common_member_declaration() throws RecognitionException { + Common_member_declarationContext _localctx = new Common_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_common_member_declaration); + try { + setState(1766); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1747); + constant_declaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1748); + typed_member_declaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1749); + event_declaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1750); + conversion_operator_declarator(); + setState(1756); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + case SEMICOLON: + { + setState(1751); + body(); + } + break; + case ASSIGNMENT: + { + setState(1752); + right_arrow(); + setState(1753); + throwable_expression(); + setState(1754); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1758); + constructor_declaration(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1759); + match(VOID); + setState(1760); + method_declaration(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1761); + class_definition(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1762); + struct_definition(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1763); + interface_definition(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1764); + enum_definition(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1765); + delegate_definition(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Typed_member_declarationContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class,0); + } + public TerminalNode DOT() { return getToken(CSharpParser.DOT, 0); } + public Indexer_declarationContext indexer_declaration() { + return getRuleContext(Indexer_declarationContext.class,0); + } + public Method_declarationContext method_declaration() { + return getRuleContext(Method_declarationContext.class,0); + } + public Property_declarationContext property_declaration() { + return getRuleContext(Property_declarationContext.class,0); + } + public Operator_declarationContext operator_declaration() { + return getRuleContext(Operator_declarationContext.class,0); + } + public Field_declarationContext field_declaration() { + return getRuleContext(Field_declarationContext.class,0); + } + public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } + public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } + public Typed_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typed_member_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterTyped_member_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitTyped_member_declaration(this); + } + } + + public final Typed_member_declarationContext typed_member_declaration() throws RecognitionException { + Typed_member_declarationContext _localctx = new Typed_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_typed_member_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1773); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) { + case 1: + { + setState(1768); + match(REF); + } + break; + case 2: + { + setState(1769); + match(READONLY); + setState(1770); + match(REF); + } + break; + case 3: + { + setState(1771); + match(REF); + setState(1772); + match(READONLY); + } + break; + } + setState(1775); + type_(); + setState(1785); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) { + case 1: + { + setState(1776); + namespace_or_type_name(); + setState(1777); + match(DOT); + setState(1778); + indexer_declaration(); + } + break; + case 2: + { + setState(1780); + method_declaration(); + } + break; + case 3: + { + setState(1781); + property_declaration(); + } + break; + case 4: + { + setState(1782); + indexer_declaration(); + } + break; + case 5: + { + setState(1783); + operator_declaration(); + } + break; + case 6: + { + setState(1784); + field_declaration(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Constant_declaratorsContext extends ParserRuleContext { + public List constant_declarator() { + return getRuleContexts(Constant_declaratorContext.class); + } + public Constant_declaratorContext constant_declarator(int i) { + return getRuleContext(Constant_declaratorContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Constant_declaratorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constant_declarators; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterConstant_declarators(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitConstant_declarators(this); + } + } + + public final Constant_declaratorsContext constant_declarators() throws RecognitionException { + Constant_declaratorsContext _localctx = new Constant_declaratorsContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_constant_declarators); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1787); + constant_declarator(); + setState(1792); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1788); + match(COMMA); + setState(1789); + constant_declarator(); + } + } + setState(1794); + _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 Constant_declaratorContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Constant_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constant_declarator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterConstant_declarator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitConstant_declarator(this); + } + } + + public final Constant_declaratorContext constant_declarator() throws RecognitionException { + Constant_declaratorContext _localctx = new Constant_declaratorContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_constant_declarator); + try { + enterOuterAlt(_localctx, 1); + { + setState(1795); + identifier(); + setState(1796); + match(ASSIGNMENT); + setState(1797); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Variable_declaratorsContext extends ParserRuleContext { + public List variable_declarator() { + return getRuleContexts(Variable_declaratorContext.class); + } + public Variable_declaratorContext variable_declarator(int i) { + return getRuleContext(Variable_declaratorContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Variable_declaratorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variable_declarators; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterVariable_declarators(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitVariable_declarators(this); + } + } + + public final Variable_declaratorsContext variable_declarators() throws RecognitionException { + Variable_declaratorsContext _localctx = new Variable_declaratorsContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_variable_declarators); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1799); + variable_declarator(); + setState(1804); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1800); + match(COMMA); + setState(1801); + variable_declarator(); + } + } + setState(1806); + _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 Variable_declaratorContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public Variable_initializerContext variable_initializer() { + return getRuleContext(Variable_initializerContext.class,0); + } + public Variable_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variable_declarator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterVariable_declarator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitVariable_declarator(this); + } + } + + public final Variable_declaratorContext variable_declarator() throws RecognitionException { + Variable_declaratorContext _localctx = new Variable_declaratorContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_variable_declarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1807); + identifier(); + setState(1810); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGNMENT) { + { + setState(1808); + match(ASSIGNMENT); + setState(1809); + variable_initializer(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Variable_initializerContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Array_initializerContext array_initializer() { + return getRuleContext(Array_initializerContext.class,0); + } + public Variable_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variable_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterVariable_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitVariable_initializer(this); + } + } + + public final Variable_initializerContext variable_initializer() throws RecognitionException { + Variable_initializerContext _localctx = new Variable_initializerContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_variable_initializer); + try { + setState(1814); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(1812); + expression(); + } + break; + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(1813); + array_initializer(); + } + 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 Return_typeContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } + public Return_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_return_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterReturn_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitReturn_type(this); + } + } + + public final Return_typeContext return_type() throws RecognitionException { + Return_typeContext _localctx = new Return_typeContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_return_type); + try { + setState(1818); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1816); + type_(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1817); + match(VOID); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Member_nameContext extends ParserRuleContext { + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class,0); + } + public Member_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_member_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMember_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMember_name(this); + } + } + + public final Member_nameContext member_name() throws RecognitionException { + Member_nameContext _localctx = new Member_nameContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_member_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(1820); + namespace_or_type_name(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Method_bodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Method_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_method_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMethod_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMethod_body(this); + } + } + + public final Method_bodyContext method_body() throws RecognitionException { + Method_bodyContext _localctx = new Method_bodyContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_method_body); + try { + setState(1824); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1822); + block(); + } + break; + case SEMICOLON: + enterOuterAlt(_localctx, 2); + { + setState(1823); + match(SEMICOLON); + } + 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 Formal_parameter_listContext extends ParserRuleContext { + public Parameter_arrayContext parameter_array() { + return getRuleContext(Parameter_arrayContext.class,0); + } + public Fixed_parametersContext fixed_parameters() { + return getRuleContext(Fixed_parametersContext.class,0); + } + public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } + public Formal_parameter_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formal_parameter_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFormal_parameter_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFormal_parameter_list(this); + } + } + + public final Formal_parameter_listContext formal_parameter_list() throws RecognitionException { + Formal_parameter_listContext _localctx = new Formal_parameter_listContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_formal_parameter_list); + int _la; + try { + setState(1832); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1826); + parameter_array(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1827); + fixed_parameters(); + setState(1830); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1828); + match(COMMA); + setState(1829); + parameter_array(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Fixed_parametersContext extends ParserRuleContext { + public List fixed_parameter() { + return getRuleContexts(Fixed_parameterContext.class); + } + public Fixed_parameterContext fixed_parameter(int i) { + return getRuleContext(Fixed_parameterContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Fixed_parametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fixed_parameters; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFixed_parameters(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFixed_parameters(this); + } + } + + public final Fixed_parametersContext fixed_parameters() throws RecognitionException { + Fixed_parametersContext _localctx = new Fixed_parametersContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_fixed_parameters); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1834); + fixed_parameter(); + setState(1839); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,210,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1835); + match(COMMA); + setState(1836); + fixed_parameter(); + } + } + } + setState(1841); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,210,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Fixed_parameterContext extends ParserRuleContext { + public Arg_declarationContext arg_declaration() { + return getRuleContext(Arg_declarationContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public Parameter_modifierContext parameter_modifier() { + return getRuleContext(Parameter_modifierContext.class,0); + } + public TerminalNode ARGLIST() { return getToken(CSharpParser.ARGLIST, 0); } + public Fixed_parameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fixed_parameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFixed_parameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFixed_parameter(this); + } + } + + public final Fixed_parameterContext fixed_parameter() throws RecognitionException { + Fixed_parameterContext _localctx = new Fixed_parameterContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_fixed_parameter); + int _la; + try { + setState(1850); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1843); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1842); + attributes(); + } + } + + setState(1846); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & ((1L << (IN - 54)) | (1L << (OUT - 54)) | (1L << (REF - 54)) | (1L << (THIS - 54)))) != 0)) { + { + setState(1845); + parameter_modifier(); + } + } + + setState(1848); + arg_declaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1849); + match(ARGLIST); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Parameter_modifierContext extends ParserRuleContext { + public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } + public TerminalNode OUT() { return getToken(CSharpParser.OUT, 0); } + public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } + public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } + public Parameter_modifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parameter_modifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterParameter_modifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitParameter_modifier(this); + } + } + + public final Parameter_modifierContext parameter_modifier() throws RecognitionException { + Parameter_modifierContext _localctx = new Parameter_modifierContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_parameter_modifier); + try { + setState(1860); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,214,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1852); + match(REF); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1853); + match(OUT); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1854); + match(IN); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1855); + match(REF); + setState(1856); + match(THIS); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1857); + match(IN); + setState(1858); + match(THIS); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1859); + match(THIS); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Parameter_arrayContext extends ParserRuleContext { + public TerminalNode PARAMS() { return getToken(CSharpParser.PARAMS, 0); } + public Array_typeContext array_type() { + return getRuleContext(Array_typeContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public Parameter_arrayContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parameter_array; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterParameter_array(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitParameter_array(this); + } + } + + public final Parameter_arrayContext parameter_array() throws RecognitionException { + Parameter_arrayContext _localctx = new Parameter_arrayContext(_ctx, getState()); + enterRule(_localctx, 288, RULE_parameter_array); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1863); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1862); + attributes(); + } + } + + setState(1865); + match(PARAMS); + setState(1866); + array_type(); + setState(1867); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Accessor_declarationsContext extends ParserRuleContext { + public AttributesContext attrs; + public Accessor_modifierContext mods; + public TerminalNode GET() { return getToken(CSharpParser.GET, 0); } + public Accessor_bodyContext accessor_body() { + return getRuleContext(Accessor_bodyContext.class,0); + } + public TerminalNode SET() { return getToken(CSharpParser.SET, 0); } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public Accessor_modifierContext accessor_modifier() { + return getRuleContext(Accessor_modifierContext.class,0); + } + public Set_accessor_declarationContext set_accessor_declaration() { + return getRuleContext(Set_accessor_declarationContext.class,0); + } + public Get_accessor_declarationContext get_accessor_declaration() { + return getRuleContext(Get_accessor_declarationContext.class,0); + } + public Accessor_declarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_accessor_declarations; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAccessor_declarations(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAccessor_declarations(this); + } + } + + public final Accessor_declarationsContext accessor_declarations() throws RecognitionException { + Accessor_declarationsContext _localctx = new Accessor_declarationsContext(_ctx, getState()); + enterRule(_localctx, 290, RULE_accessor_declarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1870); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1869); + ((Accessor_declarationsContext)_localctx).attrs = attributes(); + } + } + + setState(1873); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & ((1L << (INTERNAL - 57)) | (1L << (PRIVATE - 57)) | (1L << (PROTECTED - 57)))) != 0)) { + { + setState(1872); + ((Accessor_declarationsContext)_localctx).mods = accessor_modifier(); + } + } + + setState(1885); + _errHandler.sync(this); + switch (_input.LA(1)) { + case GET: + { + setState(1875); + match(GET); + setState(1876); + accessor_body(); + setState(1878); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTERNAL || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (PRIVATE - 76)) | (1L << (PROTECTED - 76)) | (1L << (SET - 76)) | (1L << (OPEN_BRACKET - 76)))) != 0)) { + { + setState(1877); + set_accessor_declaration(); + } + } + + } + break; + case SET: + { + setState(1880); + match(SET); + setState(1881); + accessor_body(); + setState(1883); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==GET || _la==INTERNAL || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (PRIVATE - 76)) | (1L << (PROTECTED - 76)) | (1L << (OPEN_BRACKET - 76)))) != 0)) { + { + setState(1882); + get_accessor_declaration(); + } + } + + } + 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 Get_accessor_declarationContext extends ParserRuleContext { + public TerminalNode GET() { return getToken(CSharpParser.GET, 0); } + public Accessor_bodyContext accessor_body() { + return getRuleContext(Accessor_bodyContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public Accessor_modifierContext accessor_modifier() { + return getRuleContext(Accessor_modifierContext.class,0); + } + public Get_accessor_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_get_accessor_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterGet_accessor_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitGet_accessor_declaration(this); + } + } + + public final Get_accessor_declarationContext get_accessor_declaration() throws RecognitionException { + Get_accessor_declarationContext _localctx = new Get_accessor_declarationContext(_ctx, getState()); + enterRule(_localctx, 292, RULE_get_accessor_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1888); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1887); + attributes(); + } + } + + setState(1891); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & ((1L << (INTERNAL - 57)) | (1L << (PRIVATE - 57)) | (1L << (PROTECTED - 57)))) != 0)) { + { + setState(1890); + accessor_modifier(); + } + } + + setState(1893); + match(GET); + setState(1894); + accessor_body(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Set_accessor_declarationContext extends ParserRuleContext { + public TerminalNode SET() { return getToken(CSharpParser.SET, 0); } + public Accessor_bodyContext accessor_body() { + return getRuleContext(Accessor_bodyContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public Accessor_modifierContext accessor_modifier() { + return getRuleContext(Accessor_modifierContext.class,0); + } + public Set_accessor_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_set_accessor_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterSet_accessor_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitSet_accessor_declaration(this); + } + } + + public final Set_accessor_declarationContext set_accessor_declaration() throws RecognitionException { + Set_accessor_declarationContext _localctx = new Set_accessor_declarationContext(_ctx, getState()); + enterRule(_localctx, 294, RULE_set_accessor_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1897); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1896); + attributes(); + } + } + + setState(1900); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & ((1L << (INTERNAL - 57)) | (1L << (PRIVATE - 57)) | (1L << (PROTECTED - 57)))) != 0)) { + { + setState(1899); + accessor_modifier(); + } + } + + setState(1902); + match(SET); + setState(1903); + accessor_body(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Accessor_modifierContext extends ParserRuleContext { + public TerminalNode PROTECTED() { return getToken(CSharpParser.PROTECTED, 0); } + public TerminalNode INTERNAL() { return getToken(CSharpParser.INTERNAL, 0); } + public TerminalNode PRIVATE() { return getToken(CSharpParser.PRIVATE, 0); } + public Accessor_modifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_accessor_modifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAccessor_modifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAccessor_modifier(this); + } + } + + public final Accessor_modifierContext accessor_modifier() throws RecognitionException { + Accessor_modifierContext _localctx = new Accessor_modifierContext(_ctx, getState()); + enterRule(_localctx, 296, RULE_accessor_modifier); + try { + setState(1912); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1905); + match(PROTECTED); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1906); + match(INTERNAL); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1907); + match(PRIVATE); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1908); + match(PROTECTED); + setState(1909); + match(INTERNAL); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1910); + match(INTERNAL); + setState(1911); + match(PROTECTED); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Accessor_bodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Accessor_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_accessor_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAccessor_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAccessor_body(this); + } + } + + public final Accessor_bodyContext accessor_body() throws RecognitionException { + Accessor_bodyContext _localctx = new Accessor_bodyContext(_ctx, getState()); + enterRule(_localctx, 298, RULE_accessor_body); + try { + setState(1916); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1914); + block(); + } + break; + case SEMICOLON: + enterOuterAlt(_localctx, 2); + { + setState(1915); + match(SEMICOLON); + } + 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 Event_accessor_declarationsContext extends ParserRuleContext { + public TerminalNode ADD() { return getToken(CSharpParser.ADD, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public Remove_accessor_declarationContext remove_accessor_declaration() { + return getRuleContext(Remove_accessor_declarationContext.class,0); + } + public TerminalNode REMOVE() { return getToken(CSharpParser.REMOVE, 0); } + public Add_accessor_declarationContext add_accessor_declaration() { + return getRuleContext(Add_accessor_declarationContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public Event_accessor_declarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_event_accessor_declarations; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterEvent_accessor_declarations(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitEvent_accessor_declarations(this); + } + } + + public final Event_accessor_declarationsContext event_accessor_declarations() throws RecognitionException { + Event_accessor_declarationsContext _localctx = new Event_accessor_declarationsContext(_ctx, getState()); + enterRule(_localctx, 300, RULE_event_accessor_declarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1919); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1918); + attributes(); + } + } + + setState(1929); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + { + setState(1921); + match(ADD); + setState(1922); + block(); + setState(1923); + remove_accessor_declaration(); + } + break; + case REMOVE: + { + setState(1925); + match(REMOVE); + setState(1926); + block(); + setState(1927); + add_accessor_declaration(); + } + 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 Add_accessor_declarationContext extends ParserRuleContext { + public TerminalNode ADD() { return getToken(CSharpParser.ADD, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public Add_accessor_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_add_accessor_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAdd_accessor_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAdd_accessor_declaration(this); + } + } + + public final Add_accessor_declarationContext add_accessor_declaration() throws RecognitionException { + Add_accessor_declarationContext _localctx = new Add_accessor_declarationContext(_ctx, getState()); + enterRule(_localctx, 302, RULE_add_accessor_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1932); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1931); + attributes(); + } + } + + setState(1934); + match(ADD); + setState(1935); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Remove_accessor_declarationContext extends ParserRuleContext { + public TerminalNode REMOVE() { return getToken(CSharpParser.REMOVE, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public Remove_accessor_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_remove_accessor_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterRemove_accessor_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitRemove_accessor_declaration(this); + } + } + + public final Remove_accessor_declarationContext remove_accessor_declaration() throws RecognitionException { + Remove_accessor_declarationContext _localctx = new Remove_accessor_declarationContext(_ctx, getState()); + enterRule(_localctx, 304, RULE_remove_accessor_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1938); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1937); + attributes(); + } + } + + setState(1940); + match(REMOVE); + setState(1941); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Overloadable_operatorContext extends ParserRuleContext { + public TerminalNode PLUS() { return getToken(CSharpParser.PLUS, 0); } + public TerminalNode MINUS() { return getToken(CSharpParser.MINUS, 0); } + public TerminalNode BANG() { return getToken(CSharpParser.BANG, 0); } + public TerminalNode TILDE() { return getToken(CSharpParser.TILDE, 0); } + public TerminalNode OP_INC() { return getToken(CSharpParser.OP_INC, 0); } + public TerminalNode OP_DEC() { return getToken(CSharpParser.OP_DEC, 0); } + public TerminalNode TRUE() { return getToken(CSharpParser.TRUE, 0); } + public TerminalNode FALSE() { return getToken(CSharpParser.FALSE, 0); } + public TerminalNode STAR() { return getToken(CSharpParser.STAR, 0); } + public TerminalNode DIV() { return getToken(CSharpParser.DIV, 0); } + public TerminalNode PERCENT() { return getToken(CSharpParser.PERCENT, 0); } + public TerminalNode AMP() { return getToken(CSharpParser.AMP, 0); } + public TerminalNode BITWISE_OR() { return getToken(CSharpParser.BITWISE_OR, 0); } + public TerminalNode CARET() { return getToken(CSharpParser.CARET, 0); } + public TerminalNode OP_LEFT_SHIFT() { return getToken(CSharpParser.OP_LEFT_SHIFT, 0); } + public Right_shiftContext right_shift() { + return getRuleContext(Right_shiftContext.class,0); + } + public TerminalNode OP_EQ() { return getToken(CSharpParser.OP_EQ, 0); } + public TerminalNode OP_NE() { return getToken(CSharpParser.OP_NE, 0); } + public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } + public TerminalNode LT() { return getToken(CSharpParser.LT, 0); } + public TerminalNode OP_GE() { return getToken(CSharpParser.OP_GE, 0); } + public TerminalNode OP_LE() { return getToken(CSharpParser.OP_LE, 0); } + public Overloadable_operatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_overloadable_operator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterOverloadable_operator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitOverloadable_operator(this); + } + } + + public final Overloadable_operatorContext overloadable_operator() throws RecognitionException { + Overloadable_operatorContext _localctx = new Overloadable_operatorContext(_ctx, getState()); + enterRule(_localctx, 306, RULE_overloadable_operator); + try { + setState(1965); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,231,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1943); + match(PLUS); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1944); + match(MINUS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1945); + match(BANG); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1946); + match(TILDE); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1947); + match(OP_INC); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1948); + match(OP_DEC); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1949); + match(TRUE); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1950); + match(FALSE); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1951); + match(STAR); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1952); + match(DIV); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1953); + match(PERCENT); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(1954); + match(AMP); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(1955); + match(BITWISE_OR); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(1956); + match(CARET); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(1957); + match(OP_LEFT_SHIFT); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(1958); + right_shift(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(1959); + match(OP_EQ); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(1960); + match(OP_NE); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(1961); + match(GT); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(1962); + match(LT); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(1963); + match(OP_GE); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(1964); + match(OP_LE); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Conversion_operator_declaratorContext extends ParserRuleContext { + public TerminalNode OPERATOR() { return getToken(CSharpParser.OPERATOR, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public Arg_declarationContext arg_declaration() { + return getRuleContext(Arg_declarationContext.class,0); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public TerminalNode IMPLICIT() { return getToken(CSharpParser.IMPLICIT, 0); } + public TerminalNode EXPLICIT() { return getToken(CSharpParser.EXPLICIT, 0); } + public Conversion_operator_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conversion_operator_declarator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterConversion_operator_declarator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitConversion_operator_declarator(this); + } + } + + public final Conversion_operator_declaratorContext conversion_operator_declarator() throws RecognitionException { + Conversion_operator_declaratorContext _localctx = new Conversion_operator_declaratorContext(_ctx, getState()); + enterRule(_localctx, 308, RULE_conversion_operator_declarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1967); + _la = _input.LA(1); + if ( !(_la==EXPLICIT || _la==IMPLICIT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1968); + match(OPERATOR); + setState(1969); + type_(); + setState(1970); + match(OPEN_PARENS); + setState(1971); + arg_declaration(); + setState(1972); + match(CLOSE_PARENS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Constructor_initializerContext extends ParserRuleContext { + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public TerminalNode BASE() { return getToken(CSharpParser.BASE, 0); } + public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } + public Argument_listContext argument_list() { + return getRuleContext(Argument_listContext.class,0); + } + public Constructor_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructor_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterConstructor_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitConstructor_initializer(this); + } + } + + public final Constructor_initializerContext constructor_initializer() throws RecognitionException { + Constructor_initializerContext _localctx = new Constructor_initializerContext(_ctx, getState()); + enterRule(_localctx, 310, RULE_constructor_initializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1974); + match(COLON); + setState(1975); + _la = _input.LA(1); + if ( !(_la==BASE || _la==THIS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1976); + match(OPEN_PARENS); + setState(1978); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << IN) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (OUT - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (VOID - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(1977); + argument_list(); + } + } + + setState(1980); + match(CLOSE_PARENS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public BodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitBody(this); + } + } + + public final BodyContext body() throws RecognitionException { + BodyContext _localctx = new BodyContext(_ctx, getState()); + enterRule(_localctx, 312, RULE_body); + try { + setState(1984); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1982); + block(); + } + break; + case SEMICOLON: + enterOuterAlt(_localctx, 2); + { + setState(1983); + match(SEMICOLON); + } + 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 Struct_interfacesContext extends ParserRuleContext { + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public Interface_type_listContext interface_type_list() { + return getRuleContext(Interface_type_listContext.class,0); + } + public Struct_interfacesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_struct_interfaces; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterStruct_interfaces(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitStruct_interfaces(this); + } + } + + public final Struct_interfacesContext struct_interfaces() throws RecognitionException { + Struct_interfacesContext _localctx = new Struct_interfacesContext(_ctx, getState()); + enterRule(_localctx, 314, RULE_struct_interfaces); + try { + enterOuterAlt(_localctx, 1); + { + setState(1986); + match(COLON); + setState(1987); + interface_type_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Struct_bodyContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public List struct_member_declaration() { + return getRuleContexts(Struct_member_declarationContext.class); + } + public Struct_member_declarationContext struct_member_declaration(int i) { + return getRuleContext(Struct_member_declarationContext.class,i); + } + public Struct_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_struct_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterStruct_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitStruct_body(this); + } + } + + public final Struct_bodyContext struct_body() throws RecognitionException { + Struct_bodyContext _localctx = new Struct_bodyContext(_ctx, getState()); + enterRule(_localctx, 316, RULE_struct_body); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1989); + match(OPEN_BRACE); + setState(1993); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 9)) & ~0x3f) == 0 && ((1L << (_la - 9)) & ((1L << (ABSTRACT - 9)) | (1L << (ADD - 9)) | (1L << (ALIAS - 9)) | (1L << (ARGLIST - 9)) | (1L << (ASCENDING - 9)) | (1L << (ASYNC - 9)) | (1L << (AWAIT - 9)) | (1L << (BOOL - 9)) | (1L << (BY - 9)) | (1L << (BYTE - 9)) | (1L << (CHAR - 9)) | (1L << (CLASS - 9)) | (1L << (CONST - 9)) | (1L << (DECIMAL - 9)) | (1L << (DELEGATE - 9)) | (1L << (DESCENDING - 9)) | (1L << (DOUBLE - 9)) | (1L << (DYNAMIC - 9)) | (1L << (ENUM - 9)) | (1L << (EQUALS - 9)) | (1L << (EVENT - 9)) | (1L << (EXPLICIT - 9)) | (1L << (EXTERN - 9)) | (1L << (FIXED - 9)) | (1L << (FLOAT - 9)) | (1L << (FROM - 9)) | (1L << (GET - 9)) | (1L << (GROUP - 9)) | (1L << (IMPLICIT - 9)) | (1L << (INT - 9)) | (1L << (INTERFACE - 9)) | (1L << (INTERNAL - 9)) | (1L << (INTO - 9)) | (1L << (JOIN - 9)) | (1L << (LET - 9)) | (1L << (LONG - 9)) | (1L << (NAMEOF - 9)) | (1L << (NEW - 9)) | (1L << (OBJECT - 9)) | (1L << (ON - 9)) | (1L << (ORDERBY - 9)))) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (OVERRIDE - 73)) | (1L << (PARTIAL - 73)) | (1L << (PRIVATE - 73)) | (1L << (PROTECTED - 73)) | (1L << (PUBLIC - 73)) | (1L << (READONLY - 73)) | (1L << (REF - 73)) | (1L << (REMOVE - 73)) | (1L << (SBYTE - 73)) | (1L << (SEALED - 73)) | (1L << (SELECT - 73)) | (1L << (SET - 73)) | (1L << (SHORT - 73)) | (1L << (STATIC - 73)) | (1L << (STRING - 73)) | (1L << (STRUCT - 73)) | (1L << (UINT - 73)) | (1L << (ULONG - 73)) | (1L << (UNMANAGED - 73)) | (1L << (UNSAFE - 73)) | (1L << (USHORT - 73)) | (1L << (VAR - 73)) | (1L << (VIRTUAL - 73)) | (1L << (VOID - 73)) | (1L << (VOLATILE - 73)) | (1L << (WHEN - 73)) | (1L << (WHERE - 73)) | (1L << (YIELD - 73)) | (1L << (IDENTIFIER - 73)) | (1L << (OPEN_BRACKET - 73)) | (1L << (OPEN_PARENS - 73)))) != 0)) { + { + { + setState(1990); + struct_member_declaration(); + } + } + setState(1995); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1996); + match(CLOSE_BRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Struct_member_declarationContext extends ParserRuleContext { + public Common_member_declarationContext common_member_declaration() { + return getRuleContext(Common_member_declarationContext.class,0); + } + public TerminalNode FIXED() { return getToken(CSharpParser.FIXED, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public All_member_modifiersContext all_member_modifiers() { + return getRuleContext(All_member_modifiersContext.class,0); + } + public List fixed_size_buffer_declarator() { + return getRuleContexts(Fixed_size_buffer_declaratorContext.class); + } + public Fixed_size_buffer_declaratorContext fixed_size_buffer_declarator(int i) { + return getRuleContext(Fixed_size_buffer_declaratorContext.class,i); + } + public Struct_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_struct_member_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterStruct_member_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitStruct_member_declaration(this); + } + } + + public final Struct_member_declarationContext struct_member_declaration() throws RecognitionException { + Struct_member_declarationContext _localctx = new Struct_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 318, RULE_struct_member_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1999); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(1998); + attributes(); + } + } + + setState(2002); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,236,_ctx) ) { + case 1: + { + setState(2001); + all_member_modifiers(); + } + break; + } + setState(2014); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CLASS: + case CONST: + case DECIMAL: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case ENUM: + case EQUALS: + case EVENT: + case EXPLICIT: + case FLOAT: + case FROM: + case GET: + case GROUP: + case IMPLICIT: + case INT: + case INTERFACE: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case READONLY: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case STRING: + case STRUCT: + case UINT: + case ULONG: + case UNMANAGED: + case USHORT: + case VAR: + case VOID: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case OPEN_PARENS: + { + setState(2004); + common_member_declaration(); + } + break; + case FIXED: + { + setState(2005); + match(FIXED); + setState(2006); + type_(); + setState(2008); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2007); + fixed_size_buffer_declarator(); + } + } + setState(2010); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)))) != 0) ); + setState(2012); + match(SEMICOLON); + } + 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 Array_typeContext extends ParserRuleContext { + public Base_typeContext base_type() { + return getRuleContext(Base_typeContext.class,0); + } + public List rank_specifier() { + return getRuleContexts(Rank_specifierContext.class); + } + public Rank_specifierContext rank_specifier(int i) { + return getRuleContext(Rank_specifierContext.class,i); + } + public List STAR() { return getTokens(CSharpParser.STAR); } + public TerminalNode STAR(int i) { + return getToken(CSharpParser.STAR, i); + } + public List INTERR() { return getTokens(CSharpParser.INTERR); } + public TerminalNode INTERR(int i) { + return getToken(CSharpParser.INTERR, i); + } + public Array_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_array_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterArray_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitArray_type(this); + } + } + + public final Array_typeContext array_type() throws RecognitionException { + Array_typeContext _localctx = new Array_typeContext(_ctx, getState()); + enterRule(_localctx, 320, RULE_array_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2016); + base_type(); + setState(2024); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2020); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==STAR || _la==INTERR) { + { + { + setState(2017); + _la = _input.LA(1); + if ( !(_la==STAR || _la==INTERR) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + setState(2022); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2023); + rank_specifier(); + } + } + setState(2026); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( ((((_la - 127)) & ~0x3f) == 0 && ((1L << (_la - 127)) & ((1L << (OPEN_BRACKET - 127)) | (1L << (STAR - 127)) | (1L << (INTERR - 127)))) != 0) ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Rank_specifierContext extends ParserRuleContext { + public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } + public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Rank_specifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rank_specifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterRank_specifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitRank_specifier(this); + } + } + + public final Rank_specifierContext rank_specifier() throws RecognitionException { + Rank_specifierContext _localctx = new Rank_specifierContext(_ctx, getState()); + enterRule(_localctx, 322, RULE_rank_specifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2028); + match(OPEN_BRACKET); + setState(2032); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2029); + match(COMMA); + } + } + setState(2034); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2035); + match(CLOSE_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Array_initializerContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public List variable_initializer() { + return getRuleContexts(Variable_initializerContext.class); + } + public Variable_initializerContext variable_initializer(int i) { + return getRuleContext(Variable_initializerContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Array_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_array_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterArray_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitArray_initializer(this); + } + } + + public final Array_initializerContext array_initializer() throws RecognitionException { + Array_initializerContext _localctx = new Array_initializerContext(_ctx, getState()); + enterRule(_localctx, 324, RULE_array_initializer); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2037); + match(OPEN_BRACE); + setState(2049); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)) | (1L << (OPEN_BRACE - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(2038); + variable_initializer(); + setState(2043); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,242,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2039); + match(COMMA); + setState(2040); + variable_initializer(); + } + } + } + setState(2045); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,242,_ctx); + } + setState(2047); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2046); + match(COMMA); + } + } + + } + } + + setState(2051); + match(CLOSE_BRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Variant_type_parameter_listContext extends ParserRuleContext { + public TerminalNode LT() { return getToken(CSharpParser.LT, 0); } + public List variant_type_parameter() { + return getRuleContexts(Variant_type_parameterContext.class); + } + public Variant_type_parameterContext variant_type_parameter(int i) { + return getRuleContext(Variant_type_parameterContext.class,i); + } + public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Variant_type_parameter_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variant_type_parameter_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterVariant_type_parameter_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitVariant_type_parameter_list(this); + } + } + + public final Variant_type_parameter_listContext variant_type_parameter_list() throws RecognitionException { + Variant_type_parameter_listContext _localctx = new Variant_type_parameter_listContext(_ctx, getState()); + enterRule(_localctx, 326, RULE_variant_type_parameter_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2053); + match(LT); + setState(2054); + variant_type_parameter(); + setState(2059); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2055); + match(COMMA); + setState(2056); + variant_type_parameter(); + } + } + setState(2061); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2062); + match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Variant_type_parameterContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public Variance_annotationContext variance_annotation() { + return getRuleContext(Variance_annotationContext.class,0); + } + public Variant_type_parameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variant_type_parameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterVariant_type_parameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitVariant_type_parameter(this); + } + } + + public final Variant_type_parameterContext variant_type_parameter() throws RecognitionException { + Variant_type_parameterContext _localctx = new Variant_type_parameterContext(_ctx, getState()); + enterRule(_localctx, 328, RULE_variant_type_parameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2065); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(2064); + attributes(); + } + } + + setState(2068); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN || _la==OUT) { + { + setState(2067); + variance_annotation(); + } + } + + setState(2070); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Variance_annotationContext extends ParserRuleContext { + public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } + public TerminalNode OUT() { return getToken(CSharpParser.OUT, 0); } + public Variance_annotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variance_annotation; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterVariance_annotation(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitVariance_annotation(this); + } + } + + public final Variance_annotationContext variance_annotation() throws RecognitionException { + Variance_annotationContext _localctx = new Variance_annotationContext(_ctx, getState()); + enterRule(_localctx, 330, RULE_variance_annotation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2072); + _la = _input.LA(1); + if ( !(_la==IN || _la==OUT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Interface_baseContext extends ParserRuleContext { + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public Interface_type_listContext interface_type_list() { + return getRuleContext(Interface_type_listContext.class,0); + } + public Interface_baseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interface_base; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInterface_base(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInterface_base(this); + } + } + + public final Interface_baseContext interface_base() throws RecognitionException { + Interface_baseContext _localctx = new Interface_baseContext(_ctx, getState()); + enterRule(_localctx, 332, RULE_interface_base); + try { + enterOuterAlt(_localctx, 1); + { + setState(2074); + match(COLON); + setState(2075); + interface_type_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Interface_bodyContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public List interface_member_declaration() { + return getRuleContexts(Interface_member_declarationContext.class); + } + public Interface_member_declarationContext interface_member_declaration(int i) { + return getRuleContext(Interface_member_declarationContext.class,i); + } + public Interface_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interface_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInterface_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInterface_body(this); + } + } + + public final Interface_bodyContext interface_body() throws RecognitionException { + Interface_bodyContext _localctx = new Interface_bodyContext(_ctx, getState()); + enterRule(_localctx, 334, RULE_interface_body); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2077); + match(OPEN_BRACE); + setState(2081); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (EVENT - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (NEW - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (PARTIAL - 75)) | (1L << (READONLY - 75)) | (1L << (REF - 75)) | (1L << (REMOVE - 75)) | (1L << (SBYTE - 75)) | (1L << (SELECT - 75)) | (1L << (SET - 75)) | (1L << (SHORT - 75)) | (1L << (STRING - 75)) | (1L << (UINT - 75)) | (1L << (ULONG - 75)) | (1L << (UNMANAGED - 75)) | (1L << (UNSAFE - 75)) | (1L << (USHORT - 75)) | (1L << (VAR - 75)) | (1L << (VOID - 75)) | (1L << (WHEN - 75)) | (1L << (WHERE - 75)) | (1L << (YIELD - 75)) | (1L << (IDENTIFIER - 75)) | (1L << (OPEN_BRACKET - 75)) | (1L << (OPEN_PARENS - 75)))) != 0)) { + { + { + setState(2078); + interface_member_declaration(); + } + } + setState(2083); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2084); + match(CLOSE_BRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Interface_member_declarationContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public TerminalNode EVENT() { return getToken(CSharpParser.EVENT, 0); } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public TerminalNode NEW() { return getToken(CSharpParser.NEW, 0); } + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public Interface_accessorsContext interface_accessors() { + return getRuleContext(Interface_accessorsContext.class,0); + } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } + public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class,0); + } + public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } + public TerminalNode UNSAFE() { return getToken(CSharpParser.UNSAFE, 0); } + public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } + public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } + public Type_parameter_listContext type_parameter_list() { + return getRuleContext(Type_parameter_listContext.class,0); + } + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class,0); + } + public Interface_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interface_member_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInterface_member_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInterface_member_declaration(this); + } + } + + public final Interface_member_declarationContext interface_member_declaration() throws RecognitionException { + Interface_member_declarationContext _localctx = new Interface_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 336, RULE_interface_member_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2087); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(2086); + attributes(); + } + } + + setState(2090); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NEW) { + { + setState(2089); + match(NEW); + } + } + + setState(2155); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,261,_ctx) ) { + case 1: + { + setState(2093); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==UNSAFE) { + { + setState(2092); + match(UNSAFE); + } + } + + setState(2100); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,252,_ctx) ) { + case 1: + { + setState(2095); + match(REF); + } + break; + case 2: + { + setState(2096); + match(REF); + setState(2097); + match(READONLY); + } + break; + case 3: + { + setState(2098); + match(READONLY); + setState(2099); + match(REF); + } + break; + } + setState(2102); + type_(); + setState(2130); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,256,_ctx) ) { + case 1: + { + setState(2103); + identifier(); + setState(2105); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2104); + type_parameter_list(); + } + } + + setState(2107); + match(OPEN_PARENS); + setState(2109); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { + { + setState(2108); + formal_parameter_list(); + } + } + + setState(2111); + match(CLOSE_PARENS); + setState(2113); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(2112); + type_parameter_constraints_clauses(); + } + } + + setState(2115); + match(SEMICOLON); + } + break; + case 2: + { + setState(2117); + identifier(); + setState(2118); + match(OPEN_BRACE); + setState(2119); + interface_accessors(); + setState(2120); + match(CLOSE_BRACE); + } + break; + case 3: + { + setState(2122); + match(THIS); + setState(2123); + match(OPEN_BRACKET); + setState(2124); + formal_parameter_list(); + setState(2125); + match(CLOSE_BRACKET); + setState(2126); + match(OPEN_BRACE); + setState(2127); + interface_accessors(); + setState(2128); + match(CLOSE_BRACE); + } + break; + } + } + break; + case 2: + { + setState(2133); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==UNSAFE) { + { + setState(2132); + match(UNSAFE); + } + } + + setState(2135); + match(VOID); + setState(2136); + identifier(); + setState(2138); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2137); + type_parameter_list(); + } + } + + setState(2140); + match(OPEN_PARENS); + setState(2142); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { + { + setState(2141); + formal_parameter_list(); + } + } + + setState(2144); + match(CLOSE_PARENS); + setState(2146); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(2145); + type_parameter_constraints_clauses(); + } + } + + setState(2148); + match(SEMICOLON); + } + break; + case 3: + { + setState(2150); + match(EVENT); + setState(2151); + type_(); + setState(2152); + identifier(); + setState(2153); + match(SEMICOLON); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Interface_accessorsContext extends ParserRuleContext { + public TerminalNode GET() { return getToken(CSharpParser.GET, 0); } + public List SEMICOLON() { return getTokens(CSharpParser.SEMICOLON); } + public TerminalNode SEMICOLON(int i) { + return getToken(CSharpParser.SEMICOLON, i); + } + public TerminalNode SET() { return getToken(CSharpParser.SET, 0); } + public List attributes() { + return getRuleContexts(AttributesContext.class); + } + public AttributesContext attributes(int i) { + return getRuleContext(AttributesContext.class,i); + } + public Interface_accessorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interface_accessors; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInterface_accessors(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInterface_accessors(this); + } + } + + public final Interface_accessorsContext interface_accessors() throws RecognitionException { + Interface_accessorsContext _localctx = new Interface_accessorsContext(_ctx, getState()); + enterRule(_localctx, 338, RULE_interface_accessors); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2158); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(2157); + attributes(); + } + } + + setState(2178); + _errHandler.sync(this); + switch (_input.LA(1)) { + case GET: + { + setState(2160); + match(GET); + setState(2161); + match(SEMICOLON); + setState(2167); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SET || _la==OPEN_BRACKET) { + { + setState(2163); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(2162); + attributes(); + } + } + + setState(2165); + match(SET); + setState(2166); + match(SEMICOLON); + } + } + + } + break; + case SET: + { + setState(2169); + match(SET); + setState(2170); + match(SEMICOLON); + setState(2176); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==GET || _la==OPEN_BRACKET) { + { + setState(2172); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(2171); + attributes(); + } + } + + setState(2174); + match(GET); + setState(2175); + match(SEMICOLON); + } + } + + } + 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 Enum_baseContext extends ParserRuleContext { + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public Enum_baseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enum_base; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterEnum_base(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitEnum_base(this); + } + } + + public final Enum_baseContext enum_base() throws RecognitionException { + Enum_baseContext _localctx = new Enum_baseContext(_ctx, getState()); + enterRule(_localctx, 340, RULE_enum_base); + try { + enterOuterAlt(_localctx, 1); + { + setState(2180); + match(COLON); + setState(2181); + type_(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Enum_bodyContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public List enum_member_declaration() { + return getRuleContexts(Enum_member_declarationContext.class); + } + public Enum_member_declarationContext enum_member_declaration(int i) { + return getRuleContext(Enum_member_declarationContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Enum_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enum_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterEnum_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitEnum_body(this); + } + } + + public final Enum_bodyContext enum_body() throws RecognitionException { + Enum_bodyContext _localctx = new Enum_bodyContext(_ctx, getState()); + enterRule(_localctx, 342, RULE_enum_body); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2183); + match(OPEN_BRACE); + setState(2195); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (OPEN_BRACKET - 64)))) != 0)) { + { + setState(2184); + enum_member_declaration(); + setState(2189); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,268,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2185); + match(COMMA); + setState(2186); + enum_member_declaration(); + } + } + } + setState(2191); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,268,_ctx); + } + setState(2193); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2192); + match(COMMA); + } + } + + } + } + + setState(2197); + match(CLOSE_BRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Enum_member_declarationContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Enum_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enum_member_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterEnum_member_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitEnum_member_declaration(this); + } + } + + public final Enum_member_declarationContext enum_member_declaration() throws RecognitionException { + Enum_member_declarationContext _localctx = new Enum_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 344, RULE_enum_member_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2200); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET) { + { + setState(2199); + attributes(); + } + } + + setState(2202); + identifier(); + setState(2205); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGNMENT) { + { + setState(2203); + match(ASSIGNMENT); + setState(2204); + expression(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Global_attribute_sectionContext extends ParserRuleContext { + public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } + public Global_attribute_targetContext global_attribute_target() { + return getRuleContext(Global_attribute_targetContext.class,0); + } + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public Attribute_listContext attribute_list() { + return getRuleContext(Attribute_listContext.class,0); + } + public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } + public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } + public Global_attribute_sectionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_global_attribute_section; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterGlobal_attribute_section(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitGlobal_attribute_section(this); + } + } + + public final Global_attribute_sectionContext global_attribute_section() throws RecognitionException { + Global_attribute_sectionContext _localctx = new Global_attribute_sectionContext(_ctx, getState()); + enterRule(_localctx, 346, RULE_global_attribute_section); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2207); + match(OPEN_BRACKET); + setState(2208); + global_attribute_target(); + setState(2209); + match(COLON); + setState(2210); + attribute_list(); + setState(2212); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2211); + match(COMMA); + } + } + + setState(2214); + match(CLOSE_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Global_attribute_targetContext extends ParserRuleContext { + public KeywordContext keyword() { + return getRuleContext(KeywordContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Global_attribute_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_global_attribute_target; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterGlobal_attribute_target(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitGlobal_attribute_target(this); + } + } + + public final Global_attribute_targetContext global_attribute_target() throws RecognitionException { + Global_attribute_targetContext _localctx = new Global_attribute_targetContext(_ctx, getState()); + enterRule(_localctx, 348, RULE_global_attribute_target); + try { + setState(2218); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,274,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2216); + keyword(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2217); + identifier(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AttributesContext extends ParserRuleContext { + public List attribute_section() { + return getRuleContexts(Attribute_sectionContext.class); + } + public Attribute_sectionContext attribute_section(int i) { + return getRuleContext(Attribute_sectionContext.class,i); + } + public AttributesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attributes; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAttributes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAttributes(this); + } + } + + public final AttributesContext attributes() throws RecognitionException { + AttributesContext _localctx = new AttributesContext(_ctx, getState()); + enterRule(_localctx, 350, RULE_attributes); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2221); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2220); + attribute_section(); + } + } + setState(2223); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==OPEN_BRACKET ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Attribute_sectionContext extends ParserRuleContext { + public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } + public Attribute_listContext attribute_list() { + return getRuleContext(Attribute_listContext.class,0); + } + public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } + public Attribute_targetContext attribute_target() { + return getRuleContext(Attribute_targetContext.class,0); + } + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } + public Attribute_sectionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attribute_section; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAttribute_section(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAttribute_section(this); + } + } + + public final Attribute_sectionContext attribute_section() throws RecognitionException { + Attribute_sectionContext _localctx = new Attribute_sectionContext(_ctx, getState()); + enterRule(_localctx, 352, RULE_attribute_section); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2225); + match(OPEN_BRACKET); + setState(2229); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,276,_ctx) ) { + case 1: + { + setState(2226); + attribute_target(); + setState(2227); + match(COLON); + } + break; + } + setState(2231); + attribute_list(); + setState(2233); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2232); + match(COMMA); + } + } + + setState(2235); + match(CLOSE_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Attribute_targetContext extends ParserRuleContext { + public KeywordContext keyword() { + return getRuleContext(KeywordContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Attribute_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attribute_target; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAttribute_target(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAttribute_target(this); + } + } + + public final Attribute_targetContext attribute_target() throws RecognitionException { + Attribute_targetContext _localctx = new Attribute_targetContext(_ctx, getState()); + enterRule(_localctx, 354, RULE_attribute_target); + try { + setState(2239); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,278,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2237); + keyword(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2238); + identifier(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Attribute_listContext extends ParserRuleContext { + public List attribute() { + return getRuleContexts(AttributeContext.class); + } + public AttributeContext attribute(int i) { + return getRuleContext(AttributeContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Attribute_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attribute_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAttribute_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAttribute_list(this); + } + } + + public final Attribute_listContext attribute_list() throws RecognitionException { + Attribute_listContext _localctx = new Attribute_listContext(_ctx, getState()); + enterRule(_localctx, 356, RULE_attribute_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2241); + attribute(); + setState(2246); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,279,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2242); + match(COMMA); + setState(2243); + attribute(); + } + } + } + setState(2248); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,279,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AttributeContext extends ParserRuleContext { + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class,0); + } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public List attribute_argument() { + return getRuleContexts(Attribute_argumentContext.class); + } + public Attribute_argumentContext attribute_argument(int i) { + return getRuleContext(Attribute_argumentContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public AttributeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attribute; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAttribute(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAttribute(this); + } + } + + public final AttributeContext attribute() throws RecognitionException { + AttributeContext _localctx = new AttributeContext(_ctx, getState()); + enterRule(_localctx, 358, RULE_attribute); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2249); + namespace_or_type_name(); + setState(2262); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PARENS) { + { + setState(2250); + match(OPEN_PARENS); + setState(2259); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(2251); + attribute_argument(); + setState(2256); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2252); + match(COMMA); + setState(2253); + attribute_argument(); + } + } + setState(2258); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(2261); + match(CLOSE_PARENS); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Attribute_argumentContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public Attribute_argumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attribute_argument; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterAttribute_argument(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitAttribute_argument(this); + } + } + + public final Attribute_argumentContext attribute_argument() throws RecognitionException { + Attribute_argumentContext _localctx = new Attribute_argumentContext(_ctx, getState()); + enterRule(_localctx, 360, RULE_attribute_argument); + try { + enterOuterAlt(_localctx, 1); + { + setState(2267); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,283,_ctx) ) { + case 1: + { + setState(2264); + identifier(); + setState(2265); + match(COLON); + } + break; + } + setState(2269); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Pointer_typeContext extends ParserRuleContext { + public TerminalNode STAR() { return getToken(CSharpParser.STAR, 0); } + public Simple_typeContext simple_type() { + return getRuleContext(Simple_typeContext.class,0); + } + public Class_typeContext class_type() { + return getRuleContext(Class_typeContext.class,0); + } + public List rank_specifier() { + return getRuleContexts(Rank_specifierContext.class); + } + public Rank_specifierContext rank_specifier(int i) { + return getRuleContext(Rank_specifierContext.class,i); + } + public List INTERR() { return getTokens(CSharpParser.INTERR); } + public TerminalNode INTERR(int i) { + return getToken(CSharpParser.INTERR, i); + } + public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } + public Pointer_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pointer_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterPointer_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitPointer_type(this); + } + } + + public final Pointer_typeContext pointer_type() throws RecognitionException { + Pointer_typeContext _localctx = new Pointer_typeContext(_ctx, getState()); + enterRule(_localctx, 362, RULE_pointer_type); + int _la; + try { + setState(2286); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BOOL: + case BY: + case BYTE: + case CHAR: + case DECIMAL: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case STRING: + case UINT: + case ULONG: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(2273); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BOOL: + case BYTE: + case CHAR: + case DECIMAL: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SBYTE: + case SHORT: + case UINT: + case ULONG: + case USHORT: + { + setState(2271); + simple_type(); + } + break; + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BY: + case DESCENDING: + case DYNAMIC: + case EQUALS: + case FROM: + case GET: + case GROUP: + case INTO: + case JOIN: + case LET: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SELECT: + case SET: + case STRING: + case UNMANAGED: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + { + setState(2272); + class_type(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(2279); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==OPEN_BRACKET || _la==INTERR) { + { + setState(2277); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACKET: + { + setState(2275); + rank_specifier(); + } + break; + case INTERR: + { + setState(2276); + match(INTERR); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(2281); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2282); + match(STAR); + } + break; + case VOID: + enterOuterAlt(_localctx, 2); + { + setState(2284); + match(VOID); + setState(2285); + match(STAR); + } + 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 Fixed_pointer_declaratorsContext extends ParserRuleContext { + public List fixed_pointer_declarator() { + return getRuleContexts(Fixed_pointer_declaratorContext.class); + } + public Fixed_pointer_declaratorContext fixed_pointer_declarator(int i) { + return getRuleContext(Fixed_pointer_declaratorContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Fixed_pointer_declaratorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fixed_pointer_declarators; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFixed_pointer_declarators(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFixed_pointer_declarators(this); + } + } + + public final Fixed_pointer_declaratorsContext fixed_pointer_declarators() throws RecognitionException { + Fixed_pointer_declaratorsContext _localctx = new Fixed_pointer_declaratorsContext(_ctx, getState()); + enterRule(_localctx, 364, RULE_fixed_pointer_declarators); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2288); + fixed_pointer_declarator(); + setState(2293); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2289); + match(COMMA); + setState(2290); + fixed_pointer_declarator(); + } + } + setState(2295); + _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 Fixed_pointer_declaratorContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public Fixed_pointer_initializerContext fixed_pointer_initializer() { + return getRuleContext(Fixed_pointer_initializerContext.class,0); + } + public Fixed_pointer_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fixed_pointer_declarator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFixed_pointer_declarator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFixed_pointer_declarator(this); + } + } + + public final Fixed_pointer_declaratorContext fixed_pointer_declarator() throws RecognitionException { + Fixed_pointer_declaratorContext _localctx = new Fixed_pointer_declaratorContext(_ctx, getState()); + enterRule(_localctx, 366, RULE_fixed_pointer_declarator); + try { + enterOuterAlt(_localctx, 1); + { + setState(2296); + identifier(); + setState(2297); + match(ASSIGNMENT); + setState(2298); + fixed_pointer_initializer(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Fixed_pointer_initializerContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode AMP() { return getToken(CSharpParser.AMP, 0); } + public Stackalloc_initializerContext stackalloc_initializer() { + return getRuleContext(Stackalloc_initializerContext.class,0); + } + public Fixed_pointer_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fixed_pointer_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFixed_pointer_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFixed_pointer_initializer(this); + } + } + + public final Fixed_pointer_initializerContext fixed_pointer_initializer() throws RecognitionException { + Fixed_pointer_initializerContext _localctx = new Fixed_pointer_initializerContext(_ctx, getState()); + enterRule(_localctx, 368, RULE_fixed_pointer_initializer); + try { + setState(2305); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(2301); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,289,_ctx) ) { + case 1: + { + setState(2300); + match(AMP); + } + break; + } + setState(2303); + expression(); + } + break; + case STACKALLOC: + enterOuterAlt(_localctx, 2); + { + setState(2304); + stackalloc_initializer(); + } + 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 Fixed_size_buffer_declaratorContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } + public Fixed_size_buffer_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fixed_size_buffer_declarator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterFixed_size_buffer_declarator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitFixed_size_buffer_declarator(this); + } + } + + public final Fixed_size_buffer_declaratorContext fixed_size_buffer_declarator() throws RecognitionException { + Fixed_size_buffer_declaratorContext _localctx = new Fixed_size_buffer_declaratorContext(_ctx, getState()); + enterRule(_localctx, 370, RULE_fixed_size_buffer_declarator); + try { + enterOuterAlt(_localctx, 1); + { + setState(2307); + identifier(); + setState(2308); + match(OPEN_BRACKET); + setState(2309); + expression(); + setState(2310); + match(CLOSE_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Stackalloc_initializerContext extends ParserRuleContext { + public TerminalNode STACKALLOC() { return getToken(CSharpParser.STACKALLOC, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public Stackalloc_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stackalloc_initializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterStackalloc_initializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitStackalloc_initializer(this); + } + } + + public final Stackalloc_initializerContext stackalloc_initializer() throws RecognitionException { + Stackalloc_initializerContext _localctx = new Stackalloc_initializerContext(_ctx, getState()); + enterRule(_localctx, 372, RULE_stackalloc_initializer); + int _la; + try { + int _alt; + setState(2341); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,295,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2312); + match(STACKALLOC); + setState(2313); + type_(); + setState(2314); + match(OPEN_BRACKET); + setState(2315); + expression(); + setState(2316); + match(CLOSE_BRACKET); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2318); + match(STACKALLOC); + setState(2320); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (PARTIAL - 75)) | (1L << (REMOVE - 75)) | (1L << (SBYTE - 75)) | (1L << (SELECT - 75)) | (1L << (SET - 75)) | (1L << (SHORT - 75)) | (1L << (STRING - 75)) | (1L << (UINT - 75)) | (1L << (ULONG - 75)) | (1L << (UNMANAGED - 75)) | (1L << (USHORT - 75)) | (1L << (VAR - 75)) | (1L << (VOID - 75)) | (1L << (WHEN - 75)) | (1L << (WHERE - 75)) | (1L << (YIELD - 75)) | (1L << (IDENTIFIER - 75)) | (1L << (OPEN_PARENS - 75)))) != 0)) { + { + setState(2319); + type_(); + } + } + + setState(2322); + match(OPEN_BRACKET); + setState(2324); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(2323); + expression(); + } + } + + setState(2326); + match(CLOSE_BRACKET); + setState(2327); + match(OPEN_BRACE); + setState(2328); + expression(); + setState(2333); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,293,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2329); + match(COMMA); + setState(2330); + expression(); + } + } + } + setState(2335); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,293,_ctx); + } + setState(2337); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2336); + match(COMMA); + } + } + + setState(2339); + match(CLOSE_BRACE); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Right_arrowContext extends ParserRuleContext { + public Token first; + public Token second; + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } + public Right_arrowContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_right_arrow; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterRight_arrow(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitRight_arrow(this); + } + } + + public final Right_arrowContext right_arrow() throws RecognitionException { + Right_arrowContext _localctx = new Right_arrowContext(_ctx, getState()); + enterRule(_localctx, 374, RULE_right_arrow); + try { + enterOuterAlt(_localctx, 1); + { + setState(2343); + ((Right_arrowContext)_localctx).first = match(ASSIGNMENT); + setState(2344); + ((Right_arrowContext)_localctx).second = match(GT); + setState(2345); + if (!((((Right_arrowContext)_localctx).first!=null?((Right_arrowContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_arrowContext)_localctx).second!=null?((Right_arrowContext)_localctx).second.getTokenIndex():0))) throw new FailedPredicateException(this, "$first.index + 1 == $second.index"); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Right_shiftContext extends ParserRuleContext { + public Token first; + public Token second; + public List GT() { return getTokens(CSharpParser.GT); } + public TerminalNode GT(int i) { + return getToken(CSharpParser.GT, i); + } + public Right_shiftContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_right_shift; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterRight_shift(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitRight_shift(this); + } + } + + public final Right_shiftContext right_shift() throws RecognitionException { + Right_shiftContext _localctx = new Right_shiftContext(_ctx, getState()); + enterRule(_localctx, 376, RULE_right_shift); + try { + enterOuterAlt(_localctx, 1); + { + setState(2347); + ((Right_shiftContext)_localctx).first = match(GT); + setState(2348); + ((Right_shiftContext)_localctx).second = match(GT); + setState(2349); + if (!((((Right_shiftContext)_localctx).first!=null?((Right_shiftContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_shiftContext)_localctx).second!=null?((Right_shiftContext)_localctx).second.getTokenIndex():0))) throw new FailedPredicateException(this, "$first.index + 1 == $second.index"); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Right_shift_assignmentContext extends ParserRuleContext { + public Token first; + public Token second; + public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } + public TerminalNode OP_GE() { return getToken(CSharpParser.OP_GE, 0); } + public Right_shift_assignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_right_shift_assignment; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterRight_shift_assignment(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitRight_shift_assignment(this); + } + } + + public final Right_shift_assignmentContext right_shift_assignment() throws RecognitionException { + Right_shift_assignmentContext _localctx = new Right_shift_assignmentContext(_ctx, getState()); + enterRule(_localctx, 378, RULE_right_shift_assignment); + try { + enterOuterAlt(_localctx, 1); + { + setState(2351); + ((Right_shift_assignmentContext)_localctx).first = match(GT); + setState(2352); + ((Right_shift_assignmentContext)_localctx).second = match(OP_GE); + setState(2353); + if (!((((Right_shift_assignmentContext)_localctx).first!=null?((Right_shift_assignmentContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_shift_assignmentContext)_localctx).second!=null?((Right_shift_assignmentContext)_localctx).second.getTokenIndex():0))) throw new FailedPredicateException(this, "$first.index + 1 == $second.index"); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LiteralContext extends ParserRuleContext { + public Boolean_literalContext boolean_literal() { + return getRuleContext(Boolean_literalContext.class,0); + } + public String_literalContext string_literal() { + return getRuleContext(String_literalContext.class,0); + } + public TerminalNode INTEGER_LITERAL() { return getToken(CSharpParser.INTEGER_LITERAL, 0); } + public TerminalNode HEX_INTEGER_LITERAL() { return getToken(CSharpParser.HEX_INTEGER_LITERAL, 0); } + public TerminalNode BIN_INTEGER_LITERAL() { return getToken(CSharpParser.BIN_INTEGER_LITERAL, 0); } + public TerminalNode REAL_LITERAL() { return getToken(CSharpParser.REAL_LITERAL, 0); } + public TerminalNode CHARACTER_LITERAL() { return getToken(CSharpParser.CHARACTER_LITERAL, 0); } + public TerminalNode NULL_() { return getToken(CSharpParser.NULL_, 0); } + public LiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literal; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitLiteral(this); + } + } + + public final LiteralContext literal() throws RecognitionException { + LiteralContext _localctx = new LiteralContext(_ctx, getState()); + enterRule(_localctx, 380, RULE_literal); + try { + setState(2363); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FALSE: + case TRUE: + enterOuterAlt(_localctx, 1); + { + setState(2355); + boolean_literal(); + } + break; + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + enterOuterAlt(_localctx, 2); + { + setState(2356); + string_literal(); + } + break; + case INTEGER_LITERAL: + enterOuterAlt(_localctx, 3); + { + setState(2357); + match(INTEGER_LITERAL); + } + break; + case HEX_INTEGER_LITERAL: + enterOuterAlt(_localctx, 4); + { + setState(2358); + match(HEX_INTEGER_LITERAL); + } + break; + case BIN_INTEGER_LITERAL: + enterOuterAlt(_localctx, 5); + { + setState(2359); + match(BIN_INTEGER_LITERAL); + } + break; + case REAL_LITERAL: + enterOuterAlt(_localctx, 6); + { + setState(2360); + match(REAL_LITERAL); + } + break; + case CHARACTER_LITERAL: + enterOuterAlt(_localctx, 7); + { + setState(2361); + match(CHARACTER_LITERAL); + } + break; + case NULL_: + enterOuterAlt(_localctx, 8); + { + setState(2362); + match(NULL_); + } + 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 Boolean_literalContext extends ParserRuleContext { + public TerminalNode TRUE() { return getToken(CSharpParser.TRUE, 0); } + public TerminalNode FALSE() { return getToken(CSharpParser.FALSE, 0); } + public Boolean_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_boolean_literal; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterBoolean_literal(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitBoolean_literal(this); + } + } + + public final Boolean_literalContext boolean_literal() throws RecognitionException { + Boolean_literalContext _localctx = new Boolean_literalContext(_ctx, getState()); + enterRule(_localctx, 382, RULE_boolean_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2365); + _la = _input.LA(1); + if ( !(_la==FALSE || _la==TRUE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class String_literalContext extends ParserRuleContext { + public Interpolated_regular_stringContext interpolated_regular_string() { + return getRuleContext(Interpolated_regular_stringContext.class,0); + } + public Interpolated_verbatium_stringContext interpolated_verbatium_string() { + return getRuleContext(Interpolated_verbatium_stringContext.class,0); + } + public TerminalNode REGULAR_STRING() { return getToken(CSharpParser.REGULAR_STRING, 0); } + public TerminalNode VERBATIUM_STRING() { return getToken(CSharpParser.VERBATIUM_STRING, 0); } + public String_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_string_literal; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterString_literal(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitString_literal(this); + } + } + + public final String_literalContext string_literal() throws RecognitionException { + String_literalContext _localctx = new String_literalContext(_ctx, getState()); + enterRule(_localctx, 384, RULE_string_literal); + try { + setState(2371); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INTERPOLATED_REGULAR_STRING_START: + enterOuterAlt(_localctx, 1); + { + setState(2367); + interpolated_regular_string(); + } + break; + case INTERPOLATED_VERBATIUM_STRING_START: + enterOuterAlt(_localctx, 2); + { + setState(2368); + interpolated_verbatium_string(); + } + break; + case REGULAR_STRING: + enterOuterAlt(_localctx, 3); + { + setState(2369); + match(REGULAR_STRING); + } + break; + case VERBATIUM_STRING: + enterOuterAlt(_localctx, 4); + { + setState(2370); + match(VERBATIUM_STRING); + } + 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 Interpolated_regular_stringContext extends ParserRuleContext { + public TerminalNode INTERPOLATED_REGULAR_STRING_START() { return getToken(CSharpParser.INTERPOLATED_REGULAR_STRING_START, 0); } + public TerminalNode DOUBLE_QUOTE_INSIDE() { return getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0); } + public List interpolated_regular_string_part() { + return getRuleContexts(Interpolated_regular_string_partContext.class); + } + public Interpolated_regular_string_partContext interpolated_regular_string_part(int i) { + return getRuleContext(Interpolated_regular_string_partContext.class,i); + } + public Interpolated_regular_stringContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interpolated_regular_string; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInterpolated_regular_string(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInterpolated_regular_string(this); + } + } + + public final Interpolated_regular_stringContext interpolated_regular_string() throws RecognitionException { + Interpolated_regular_stringContext _localctx = new Interpolated_regular_stringContext(_ctx, getState()); + enterRule(_localctx, 386, RULE_interpolated_regular_string); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2373); + match(INTERPOLATED_REGULAR_STRING_START); + setState(2377); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)) | (1L << (DOUBLE_CURLY_INSIDE - 129)) | (1L << (REGULAR_CHAR_INSIDE - 129)) | (1L << (REGULAR_STRING_INSIDE - 129)))) != 0)) { + { + { + setState(2374); + interpolated_regular_string_part(); + } + } + setState(2379); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2380); + match(DOUBLE_QUOTE_INSIDE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Interpolated_verbatium_stringContext extends ParserRuleContext { + public TerminalNode INTERPOLATED_VERBATIUM_STRING_START() { return getToken(CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, 0); } + public TerminalNode DOUBLE_QUOTE_INSIDE() { return getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0); } + public List interpolated_verbatium_string_part() { + return getRuleContexts(Interpolated_verbatium_string_partContext.class); + } + public Interpolated_verbatium_string_partContext interpolated_verbatium_string_part(int i) { + return getRuleContext(Interpolated_verbatium_string_partContext.class,i); + } + public Interpolated_verbatium_stringContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interpolated_verbatium_string; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInterpolated_verbatium_string(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInterpolated_verbatium_string(this); + } + } + + public final Interpolated_verbatium_stringContext interpolated_verbatium_string() throws RecognitionException { + Interpolated_verbatium_stringContext _localctx = new Interpolated_verbatium_stringContext(_ctx, getState()); + enterRule(_localctx, 388, RULE_interpolated_verbatium_string); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2382); + match(INTERPOLATED_VERBATIUM_STRING_START); + setState(2386); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)) | (1L << (DOUBLE_CURLY_INSIDE - 129)) | (1L << (VERBATIUM_DOUBLE_QUOTE_INSIDE - 129)) | (1L << (VERBATIUM_INSIDE_STRING - 129)))) != 0)) { + { + { + setState(2383); + interpolated_verbatium_string_part(); + } + } + setState(2388); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2389); + match(DOUBLE_QUOTE_INSIDE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Interpolated_regular_string_partContext extends ParserRuleContext { + public Interpolated_string_expressionContext interpolated_string_expression() { + return getRuleContext(Interpolated_string_expressionContext.class,0); + } + public TerminalNode DOUBLE_CURLY_INSIDE() { return getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0); } + public TerminalNode REGULAR_CHAR_INSIDE() { return getToken(CSharpParser.REGULAR_CHAR_INSIDE, 0); } + public TerminalNode REGULAR_STRING_INSIDE() { return getToken(CSharpParser.REGULAR_STRING_INSIDE, 0); } + public Interpolated_regular_string_partContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interpolated_regular_string_part; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInterpolated_regular_string_part(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInterpolated_regular_string_part(this); + } + } + + public final Interpolated_regular_string_partContext interpolated_regular_string_part() throws RecognitionException { + Interpolated_regular_string_partContext _localctx = new Interpolated_regular_string_partContext(_ctx, getState()); + enterRule(_localctx, 390, RULE_interpolated_regular_string_part); + try { + setState(2395); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(2391); + interpolated_string_expression(); + } + break; + case DOUBLE_CURLY_INSIDE: + enterOuterAlt(_localctx, 2); + { + setState(2392); + match(DOUBLE_CURLY_INSIDE); + } + break; + case REGULAR_CHAR_INSIDE: + enterOuterAlt(_localctx, 3); + { + setState(2393); + match(REGULAR_CHAR_INSIDE); + } + break; + case REGULAR_STRING_INSIDE: + enterOuterAlt(_localctx, 4); + { + setState(2394); + match(REGULAR_STRING_INSIDE); + } + 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 Interpolated_verbatium_string_partContext extends ParserRuleContext { + public Interpolated_string_expressionContext interpolated_string_expression() { + return getRuleContext(Interpolated_string_expressionContext.class,0); + } + public TerminalNode DOUBLE_CURLY_INSIDE() { return getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0); } + public TerminalNode VERBATIUM_DOUBLE_QUOTE_INSIDE() { return getToken(CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE, 0); } + public TerminalNode VERBATIUM_INSIDE_STRING() { return getToken(CSharpParser.VERBATIUM_INSIDE_STRING, 0); } + public Interpolated_verbatium_string_partContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interpolated_verbatium_string_part; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInterpolated_verbatium_string_part(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInterpolated_verbatium_string_part(this); + } + } + + public final Interpolated_verbatium_string_partContext interpolated_verbatium_string_part() throws RecognitionException { + Interpolated_verbatium_string_partContext _localctx = new Interpolated_verbatium_string_partContext(_ctx, getState()); + enterRule(_localctx, 392, RULE_interpolated_verbatium_string_part); + try { + setState(2401); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL_: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(2397); + interpolated_string_expression(); + } + break; + case DOUBLE_CURLY_INSIDE: + enterOuterAlt(_localctx, 2); + { + setState(2398); + match(DOUBLE_CURLY_INSIDE); + } + break; + case VERBATIUM_DOUBLE_QUOTE_INSIDE: + enterOuterAlt(_localctx, 3); + { + setState(2399); + match(VERBATIUM_DOUBLE_QUOTE_INSIDE); + } + break; + case VERBATIUM_INSIDE_STRING: + enterOuterAlt(_localctx, 4); + { + setState(2400); + match(VERBATIUM_INSIDE_STRING); + } + 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 Interpolated_string_expressionContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List COMMA() { return getTokens(CSharpParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } + public List FORMAT_STRING() { return getTokens(CSharpParser.FORMAT_STRING); } + public TerminalNode FORMAT_STRING(int i) { + return getToken(CSharpParser.FORMAT_STRING, i); + } + public Interpolated_string_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interpolated_string_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInterpolated_string_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInterpolated_string_expression(this); + } + } + + public final Interpolated_string_expressionContext interpolated_string_expression() throws RecognitionException { + Interpolated_string_expressionContext _localctx = new Interpolated_string_expressionContext(_ctx, getState()); + enterRule(_localctx, 394, RULE_interpolated_string_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2403); + expression(); + setState(2408); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2404); + match(COMMA); + setState(2405); + expression(); + } + } + setState(2410); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2417); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLON) { + { + setState(2411); + match(COLON); + setState(2413); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2412); + match(FORMAT_STRING); + } + } + setState(2415); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==FORMAT_STRING ); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class KeywordContext extends ParserRuleContext { + public TerminalNode ABSTRACT() { return getToken(CSharpParser.ABSTRACT, 0); } + public TerminalNode AS() { return getToken(CSharpParser.AS, 0); } + public TerminalNode BASE() { return getToken(CSharpParser.BASE, 0); } + public TerminalNode BOOL() { return getToken(CSharpParser.BOOL, 0); } + public TerminalNode BREAK() { return getToken(CSharpParser.BREAK, 0); } + public TerminalNode BYTE() { return getToken(CSharpParser.BYTE, 0); } + public TerminalNode CASE() { return getToken(CSharpParser.CASE, 0); } + public TerminalNode CATCH() { return getToken(CSharpParser.CATCH, 0); } + public TerminalNode CHAR() { return getToken(CSharpParser.CHAR, 0); } + public TerminalNode CHECKED() { return getToken(CSharpParser.CHECKED, 0); } + public TerminalNode CLASS() { return getToken(CSharpParser.CLASS, 0); } + public TerminalNode CONST() { return getToken(CSharpParser.CONST, 0); } + public TerminalNode CONTINUE() { return getToken(CSharpParser.CONTINUE, 0); } + public TerminalNode DECIMAL() { return getToken(CSharpParser.DECIMAL, 0); } + public TerminalNode DEFAULT() { return getToken(CSharpParser.DEFAULT, 0); } + public TerminalNode DELEGATE() { return getToken(CSharpParser.DELEGATE, 0); } + public TerminalNode DO() { return getToken(CSharpParser.DO, 0); } + public TerminalNode DOUBLE() { return getToken(CSharpParser.DOUBLE, 0); } + public TerminalNode ELSE() { return getToken(CSharpParser.ELSE, 0); } + public TerminalNode ENUM() { return getToken(CSharpParser.ENUM, 0); } + public TerminalNode EVENT() { return getToken(CSharpParser.EVENT, 0); } + public TerminalNode EXPLICIT() { return getToken(CSharpParser.EXPLICIT, 0); } + public TerminalNode EXTERN() { return getToken(CSharpParser.EXTERN, 0); } + public TerminalNode FALSE() { return getToken(CSharpParser.FALSE, 0); } + public TerminalNode FINALLY() { return getToken(CSharpParser.FINALLY, 0); } + public TerminalNode FIXED() { return getToken(CSharpParser.FIXED, 0); } + public TerminalNode FLOAT() { return getToken(CSharpParser.FLOAT, 0); } + public TerminalNode FOR() { return getToken(CSharpParser.FOR, 0); } + public TerminalNode FOREACH() { return getToken(CSharpParser.FOREACH, 0); } + public TerminalNode GOTO() { return getToken(CSharpParser.GOTO, 0); } + public TerminalNode IF() { return getToken(CSharpParser.IF, 0); } + public TerminalNode IMPLICIT() { return getToken(CSharpParser.IMPLICIT, 0); } + public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } + public TerminalNode INT() { return getToken(CSharpParser.INT, 0); } + public TerminalNode INTERFACE() { return getToken(CSharpParser.INTERFACE, 0); } + public TerminalNode INTERNAL() { return getToken(CSharpParser.INTERNAL, 0); } + public TerminalNode IS() { return getToken(CSharpParser.IS, 0); } + public TerminalNode LOCK() { return getToken(CSharpParser.LOCK, 0); } + public TerminalNode LONG() { return getToken(CSharpParser.LONG, 0); } + public TerminalNode NAMESPACE() { return getToken(CSharpParser.NAMESPACE, 0); } + public TerminalNode NEW() { return getToken(CSharpParser.NEW, 0); } + public TerminalNode NULL_() { return getToken(CSharpParser.NULL_, 0); } + public TerminalNode OBJECT() { return getToken(CSharpParser.OBJECT, 0); } + public TerminalNode OPERATOR() { return getToken(CSharpParser.OPERATOR, 0); } + public TerminalNode OUT() { return getToken(CSharpParser.OUT, 0); } + public TerminalNode OVERRIDE() { return getToken(CSharpParser.OVERRIDE, 0); } + public TerminalNode PARAMS() { return getToken(CSharpParser.PARAMS, 0); } + public TerminalNode PRIVATE() { return getToken(CSharpParser.PRIVATE, 0); } + public TerminalNode PROTECTED() { return getToken(CSharpParser.PROTECTED, 0); } + public TerminalNode PUBLIC() { return getToken(CSharpParser.PUBLIC, 0); } + public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } + public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } + public TerminalNode RETURN() { return getToken(CSharpParser.RETURN, 0); } + public TerminalNode SBYTE() { return getToken(CSharpParser.SBYTE, 0); } + public TerminalNode SEALED() { return getToken(CSharpParser.SEALED, 0); } + public TerminalNode SHORT() { return getToken(CSharpParser.SHORT, 0); } + public TerminalNode SIZEOF() { return getToken(CSharpParser.SIZEOF, 0); } + public TerminalNode STACKALLOC() { return getToken(CSharpParser.STACKALLOC, 0); } + public TerminalNode STATIC() { return getToken(CSharpParser.STATIC, 0); } + public TerminalNode STRING() { return getToken(CSharpParser.STRING, 0); } + public TerminalNode STRUCT() { return getToken(CSharpParser.STRUCT, 0); } + public TerminalNode SWITCH() { return getToken(CSharpParser.SWITCH, 0); } + public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } + public TerminalNode THROW() { return getToken(CSharpParser.THROW, 0); } + public TerminalNode TRUE() { return getToken(CSharpParser.TRUE, 0); } + public TerminalNode TRY() { return getToken(CSharpParser.TRY, 0); } + public TerminalNode TYPEOF() { return getToken(CSharpParser.TYPEOF, 0); } + public TerminalNode UINT() { return getToken(CSharpParser.UINT, 0); } + public TerminalNode ULONG() { return getToken(CSharpParser.ULONG, 0); } + public TerminalNode UNCHECKED() { return getToken(CSharpParser.UNCHECKED, 0); } + public TerminalNode UNMANAGED() { return getToken(CSharpParser.UNMANAGED, 0); } + public TerminalNode UNSAFE() { return getToken(CSharpParser.UNSAFE, 0); } + public TerminalNode USHORT() { return getToken(CSharpParser.USHORT, 0); } + public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } + public TerminalNode VIRTUAL() { return getToken(CSharpParser.VIRTUAL, 0); } + public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } + public TerminalNode VOLATILE() { return getToken(CSharpParser.VOLATILE, 0); } + public TerminalNode WHILE() { return getToken(CSharpParser.WHILE, 0); } + public KeywordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_keyword; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterKeyword(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitKeyword(this); + } + } + + public final KeywordContext keyword() throws RecognitionException { + KeywordContext _localctx = new KeywordContext(_ctx, getState()); + enterRule(_localctx, 396, RULE_keyword); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2419); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << AS) | (1L << BASE) | (1L << BOOL) | (1L << BREAK) | (1L << BYTE) | (1L << CASE) | (1L << CATCH) | (1L << CHAR) | (1L << CHECKED) | (1L << CLASS) | (1L << CONST) | (1L << CONTINUE) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DO) | (1L << DOUBLE) | (1L << ELSE) | (1L << ENUM) | (1L << EVENT) | (1L << EXPLICIT) | (1L << EXTERN) | (1L << FALSE) | (1L << FINALLY) | (1L << FIXED) | (1L << FLOAT) | (1L << FOR) | (1L << FOREACH) | (1L << GOTO) | (1L << IF) | (1L << IMPLICIT) | (1L << IN) | (1L << INT) | (1L << INTERFACE) | (1L << INTERNAL) | (1L << IS) | (1L << LOCK) | (1L << LONG))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (NAMESPACE - 65)) | (1L << (NEW - 65)) | (1L << (NULL_ - 65)) | (1L << (OBJECT - 65)) | (1L << (OPERATOR - 65)) | (1L << (OUT - 65)) | (1L << (OVERRIDE - 65)) | (1L << (PARAMS - 65)) | (1L << (PRIVATE - 65)) | (1L << (PROTECTED - 65)) | (1L << (PUBLIC - 65)) | (1L << (READONLY - 65)) | (1L << (REF - 65)) | (1L << (RETURN - 65)) | (1L << (SBYTE - 65)) | (1L << (SEALED - 65)) | (1L << (SHORT - 65)) | (1L << (SIZEOF - 65)) | (1L << (STACKALLOC - 65)) | (1L << (STATIC - 65)) | (1L << (STRING - 65)) | (1L << (STRUCT - 65)) | (1L << (SWITCH - 65)) | (1L << (THIS - 65)) | (1L << (THROW - 65)) | (1L << (TRUE - 65)) | (1L << (TRY - 65)) | (1L << (TYPEOF - 65)) | (1L << (UINT - 65)) | (1L << (ULONG - 65)) | (1L << (UNCHECKED - 65)) | (1L << (UNMANAGED - 65)) | (1L << (UNSAFE - 65)) | (1L << (USHORT - 65)) | (1L << (USING - 65)) | (1L << (VIRTUAL - 65)) | (1L << (VOID - 65)) | (1L << (VOLATILE - 65)) | (1L << (WHILE - 65)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Class_definitionContext extends ParserRuleContext { + public TerminalNode CLASS() { return getToken(CSharpParser.CLASS, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Class_bodyContext class_body() { + return getRuleContext(Class_bodyContext.class,0); + } + public Type_parameter_listContext type_parameter_list() { + return getRuleContext(Type_parameter_listContext.class,0); + } + public Class_baseContext class_base() { + return getRuleContext(Class_baseContext.class,0); + } + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Class_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_class_definition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterClass_definition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitClass_definition(this); + } + } + + public final Class_definitionContext class_definition() throws RecognitionException { + Class_definitionContext _localctx = new Class_definitionContext(_ctx, getState()); + enterRule(_localctx, 398, RULE_class_definition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2421); + match(CLASS); + setState(2422); + identifier(); + setState(2424); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2423); + type_parameter_list(); + } + } + + setState(2427); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLON) { + { + setState(2426); + class_base(); + } + } + + setState(2430); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(2429); + type_parameter_constraints_clauses(); + } + } + + setState(2432); + class_body(); + setState(2434); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEMICOLON) { + { + setState(2433); + match(SEMICOLON); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Struct_definitionContext extends ParserRuleContext { + public TerminalNode STRUCT() { return getToken(CSharpParser.STRUCT, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Struct_bodyContext struct_body() { + return getRuleContext(Struct_bodyContext.class,0); + } + public Type_parameter_listContext type_parameter_list() { + return getRuleContext(Type_parameter_listContext.class,0); + } + public Struct_interfacesContext struct_interfaces() { + return getRuleContext(Struct_interfacesContext.class,0); + } + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } + public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } + public Struct_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_struct_definition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterStruct_definition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitStruct_definition(this); + } + } + + public final Struct_definitionContext struct_definition() throws RecognitionException { + Struct_definitionContext _localctx = new Struct_definitionContext(_ctx, getState()); + enterRule(_localctx, 400, RULE_struct_definition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2437); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==READONLY || _la==REF) { + { + setState(2436); + _la = _input.LA(1); + if ( !(_la==READONLY || _la==REF) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2439); + match(STRUCT); + setState(2440); + identifier(); + setState(2442); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2441); + type_parameter_list(); + } + } + + setState(2445); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLON) { + { + setState(2444); + struct_interfaces(); + } + } + + setState(2448); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(2447); + type_parameter_constraints_clauses(); + } + } + + setState(2450); + struct_body(); + setState(2452); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEMICOLON) { + { + setState(2451); + match(SEMICOLON); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Interface_definitionContext extends ParserRuleContext { + public TerminalNode INTERFACE() { return getToken(CSharpParser.INTERFACE, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Class_bodyContext class_body() { + return getRuleContext(Class_bodyContext.class,0); + } + public Variant_type_parameter_listContext variant_type_parameter_list() { + return getRuleContext(Variant_type_parameter_listContext.class,0); + } + public Interface_baseContext interface_base() { + return getRuleContext(Interface_baseContext.class,0); + } + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Interface_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interface_definition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterInterface_definition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitInterface_definition(this); + } + } + + public final Interface_definitionContext interface_definition() throws RecognitionException { + Interface_definitionContext _localctx = new Interface_definitionContext(_ctx, getState()); + enterRule(_localctx, 402, RULE_interface_definition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2454); + match(INTERFACE); + setState(2455); + identifier(); + setState(2457); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2456); + variant_type_parameter_list(); + } + } + + setState(2460); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLON) { + { + setState(2459); + interface_base(); + } + } + + setState(2463); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(2462); + type_parameter_constraints_clauses(); + } + } + + setState(2465); + class_body(); + setState(2467); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEMICOLON) { + { + setState(2466); + match(SEMICOLON); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Enum_definitionContext extends ParserRuleContext { + public TerminalNode ENUM() { return getToken(CSharpParser.ENUM, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Enum_bodyContext enum_body() { + return getRuleContext(Enum_bodyContext.class,0); + } + public Enum_baseContext enum_base() { + return getRuleContext(Enum_baseContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Enum_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enum_definition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterEnum_definition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitEnum_definition(this); + } + } + + public final Enum_definitionContext enum_definition() throws RecognitionException { + Enum_definitionContext _localctx = new Enum_definitionContext(_ctx, getState()); + enterRule(_localctx, 404, RULE_enum_definition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2469); + match(ENUM); + setState(2470); + identifier(); + setState(2472); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLON) { + { + setState(2471); + enum_base(); + } + } + + setState(2474); + enum_body(); + setState(2476); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEMICOLON) { + { + setState(2475); + match(SEMICOLON); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Delegate_definitionContext extends ParserRuleContext { + public TerminalNode DELEGATE() { return getToken(CSharpParser.DELEGATE, 0); } + public Return_typeContext return_type() { + return getRuleContext(Return_typeContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Variant_type_parameter_listContext variant_type_parameter_list() { + return getRuleContext(Variant_type_parameter_listContext.class,0); + } + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class,0); + } + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class,0); + } + public Delegate_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_delegate_definition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterDelegate_definition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitDelegate_definition(this); + } + } + + public final Delegate_definitionContext delegate_definition() throws RecognitionException { + Delegate_definitionContext _localctx = new Delegate_definitionContext(_ctx, getState()); + enterRule(_localctx, 406, RULE_delegate_definition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2478); + match(DELEGATE); + setState(2479); + return_type(); + setState(2480); + identifier(); + setState(2482); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2481); + variant_type_parameter_list(); + } + } + + setState(2484); + match(OPEN_PARENS); + setState(2486); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { + { + setState(2485); + formal_parameter_list(); + } + } + + setState(2488); + match(CLOSE_PARENS); + setState(2490); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(2489); + type_parameter_constraints_clauses(); + } + } + + setState(2492); + match(SEMICOLON); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Event_declarationContext extends ParserRuleContext { + public TerminalNode EVENT() { return getToken(CSharpParser.EVENT, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public Variable_declaratorsContext variable_declarators() { + return getRuleContext(Variable_declaratorsContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Member_nameContext member_name() { + return getRuleContext(Member_nameContext.class,0); + } + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public Event_accessor_declarationsContext event_accessor_declarations() { + return getRuleContext(Event_accessor_declarationsContext.class,0); + } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public Event_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_event_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterEvent_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitEvent_declaration(this); + } + } + + public final Event_declarationContext event_declaration() throws RecognitionException { + Event_declarationContext _localctx = new Event_declarationContext(_ctx, getState()); + enterRule(_localctx, 408, RULE_event_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(2494); + match(EVENT); + setState(2495); + type_(); + setState(2504); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,323,_ctx) ) { + case 1: + { + setState(2496); + variable_declarators(); + setState(2497); + match(SEMICOLON); + } + break; + case 2: + { + setState(2499); + member_name(); + setState(2500); + match(OPEN_BRACE); + setState(2501); + event_accessor_declarations(); + setState(2502); + match(CLOSE_BRACE); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Field_declarationContext extends ParserRuleContext { + public Variable_declaratorsContext variable_declarators() { + return getRuleContext(Variable_declaratorsContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Field_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_field_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterField_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitField_declaration(this); + } + } + + public final Field_declarationContext field_declaration() throws RecognitionException { + Field_declarationContext _localctx = new Field_declarationContext(_ctx, getState()); + enterRule(_localctx, 410, RULE_field_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(2506); + variable_declarators(); + setState(2507); + match(SEMICOLON); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Property_declarationContext extends ParserRuleContext { + public Member_nameContext member_name() { + return getRuleContext(Member_nameContext.class,0); + } + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public Accessor_declarationsContext accessor_declarations() { + return getRuleContext(Accessor_declarationsContext.class,0); + } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class,0); + } + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public Variable_initializerContext variable_initializer() { + return getRuleContext(Variable_initializerContext.class,0); + } + public Property_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_property_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterProperty_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitProperty_declaration(this); + } + } + + public final Property_declarationContext property_declaration() throws RecognitionException { + Property_declarationContext _localctx = new Property_declarationContext(_ctx, getState()); + enterRule(_localctx, 412, RULE_property_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2509); + member_name(); + setState(2523); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + { + setState(2510); + match(OPEN_BRACE); + setState(2511); + accessor_declarations(); + setState(2512); + match(CLOSE_BRACE); + setState(2517); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGNMENT) { + { + setState(2513); + match(ASSIGNMENT); + setState(2514); + variable_initializer(); + setState(2515); + match(SEMICOLON); + } + } + + } + break; + case ASSIGNMENT: + { + setState(2519); + right_arrow(); + setState(2520); + throwable_expression(); + setState(2521); + match(SEMICOLON); + } + 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 Constant_declarationContext extends ParserRuleContext { + public TerminalNode CONST() { return getToken(CSharpParser.CONST, 0); } + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public Constant_declaratorsContext constant_declarators() { + return getRuleContext(Constant_declaratorsContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Constant_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constant_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterConstant_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitConstant_declaration(this); + } + } + + public final Constant_declarationContext constant_declaration() throws RecognitionException { + Constant_declarationContext _localctx = new Constant_declarationContext(_ctx, getState()); + enterRule(_localctx, 414, RULE_constant_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(2525); + match(CONST); + setState(2526); + type_(); + setState(2527); + constant_declarators(); + setState(2528); + match(SEMICOLON); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Indexer_declarationContext extends ParserRuleContext { + public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } + public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class,0); + } + public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } + public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } + public Accessor_declarationsContext accessor_declarations() { + return getRuleContext(Accessor_declarationsContext.class,0); + } + public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class,0); + } + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Indexer_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexer_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterIndexer_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitIndexer_declaration(this); + } + } + + public final Indexer_declarationContext indexer_declaration() throws RecognitionException { + Indexer_declarationContext _localctx = new Indexer_declarationContext(_ctx, getState()); + enterRule(_localctx, 416, RULE_indexer_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(2530); + match(THIS); + setState(2531); + match(OPEN_BRACKET); + setState(2532); + formal_parameter_list(); + setState(2533); + match(CLOSE_BRACKET); + setState(2542); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + { + setState(2534); + match(OPEN_BRACE); + setState(2535); + accessor_declarations(); + setState(2536); + match(CLOSE_BRACE); + } + break; + case ASSIGNMENT: + { + setState(2538); + right_arrow(); + setState(2539); + throwable_expression(); + setState(2540); + match(SEMICOLON); + } + 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 Destructor_definitionContext extends ParserRuleContext { + public TerminalNode TILDE() { return getToken(CSharpParser.TILDE, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public BodyContext body() { + return getRuleContext(BodyContext.class,0); + } + public Destructor_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_destructor_definition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterDestructor_definition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitDestructor_definition(this); + } + } + + public final Destructor_definitionContext destructor_definition() throws RecognitionException { + Destructor_definitionContext _localctx = new Destructor_definitionContext(_ctx, getState()); + enterRule(_localctx, 418, RULE_destructor_definition); + try { + enterOuterAlt(_localctx, 1); + { + setState(2544); + match(TILDE); + setState(2545); + identifier(); + setState(2546); + match(OPEN_PARENS); + setState(2547); + match(CLOSE_PARENS); + setState(2548); + body(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Constructor_declarationContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public BodyContext body() { + return getRuleContext(BodyContext.class,0); + } + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class,0); + } + public Constructor_initializerContext constructor_initializer() { + return getRuleContext(Constructor_initializerContext.class,0); + } + public Constructor_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructor_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterConstructor_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitConstructor_declaration(this); + } + } + + public final Constructor_declarationContext constructor_declaration() throws RecognitionException { + Constructor_declarationContext _localctx = new Constructor_declarationContext(_ctx, getState()); + enterRule(_localctx, 420, RULE_constructor_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2550); + identifier(); + setState(2551); + match(OPEN_PARENS); + setState(2553); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { + { + setState(2552); + formal_parameter_list(); + } + } + + setState(2555); + match(CLOSE_PARENS); + setState(2557); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLON) { + { + setState(2556); + constructor_initializer(); + } + } + + setState(2559); + body(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Method_declarationContext extends ParserRuleContext { + public Method_member_nameContext method_member_name() { + return getRuleContext(Method_member_nameContext.class,0); + } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Method_bodyContext method_body() { + return getRuleContext(Method_bodyContext.class,0); + } + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class,0); + } + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public Type_parameter_listContext type_parameter_list() { + return getRuleContext(Type_parameter_listContext.class,0); + } + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class,0); + } + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class,0); + } + public Method_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_method_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMethod_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMethod_declaration(this); + } + } + + public final Method_declarationContext method_declaration() throws RecognitionException { + Method_declarationContext _localctx = new Method_declarationContext(_ctx, getState()); + enterRule(_localctx, 422, RULE_method_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2561); + method_member_name(); + setState(2563); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2562); + type_parameter_list(); + } + } + + setState(2565); + match(OPEN_PARENS); + setState(2567); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { + { + setState(2566); + formal_parameter_list(); + } + } + + setState(2569); + match(CLOSE_PARENS); + setState(2571); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(2570); + type_parameter_constraints_clauses(); + } + } + + setState(2578); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + case SEMICOLON: + { + setState(2573); + method_body(); + } + break; + case ASSIGNMENT: + { + setState(2574); + right_arrow(); + setState(2575); + throwable_expression(); + setState(2576); + match(SEMICOLON); + } + 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 Method_member_nameContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public TerminalNode DOUBLE_COLON() { return getToken(CSharpParser.DOUBLE_COLON, 0); } + public List DOT() { return getTokens(CSharpParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(CSharpParser.DOT, i); + } + public List type_argument_list() { + return getRuleContexts(Type_argument_listContext.class); + } + public Type_argument_listContext type_argument_list(int i) { + return getRuleContext(Type_argument_listContext.class,i); + } + public Method_member_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_method_member_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMethod_member_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMethod_member_name(this); + } + } + + public final Method_member_nameContext method_member_name() throws RecognitionException { + Method_member_nameContext _localctx = new Method_member_nameContext(_ctx, getState()); + enterRule(_localctx, 424, RULE_method_member_name); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2585); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,333,_ctx) ) { + case 1: + { + setState(2580); + identifier(); + } + break; + case 2: + { + setState(2581); + identifier(); + setState(2582); + match(DOUBLE_COLON); + setState(2583); + identifier(); + } + break; + } + setState(2594); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,335,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2588); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2587); + type_argument_list(); + } + } + + setState(2590); + match(DOT); + setState(2591); + identifier(); + } + } + } + setState(2596); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,335,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Operator_declarationContext extends ParserRuleContext { + public TerminalNode OPERATOR() { return getToken(CSharpParser.OPERATOR, 0); } + public Overloadable_operatorContext overloadable_operator() { + return getRuleContext(Overloadable_operatorContext.class,0); + } + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public List arg_declaration() { + return getRuleContexts(Arg_declarationContext.class); + } + public Arg_declarationContext arg_declaration(int i) { + return getRuleContext(Arg_declarationContext.class,i); + } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public BodyContext body() { + return getRuleContext(BodyContext.class,0); + } + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class,0); + } + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } + public List IN() { return getTokens(CSharpParser.IN); } + public TerminalNode IN(int i) { + return getToken(CSharpParser.IN, i); + } + public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } + public Operator_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_operator_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterOperator_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitOperator_declaration(this); + } + } + + public final Operator_declarationContext operator_declaration() throws RecognitionException { + Operator_declarationContext _localctx = new Operator_declarationContext(_ctx, getState()); + enterRule(_localctx, 426, RULE_operator_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2597); + match(OPERATOR); + setState(2598); + overloadable_operator(); + setState(2599); + match(OPEN_PARENS); + setState(2601); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN) { + { + setState(2600); + match(IN); + } + } + + setState(2603); + arg_declaration(); + setState(2609); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2604); + match(COMMA); + setState(2606); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN) { + { + setState(2605); + match(IN); + } + } + + setState(2608); + arg_declaration(); + } + } + + setState(2611); + match(CLOSE_PARENS); + setState(2617); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + case SEMICOLON: + { + setState(2612); + body(); + } + break; + case ASSIGNMENT: + { + setState(2613); + right_arrow(); + setState(2614); + throwable_expression(); + setState(2615); + match(SEMICOLON); + } + 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 Arg_declarationContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public Arg_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arg_declaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterArg_declaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitArg_declaration(this); + } + } + + public final Arg_declarationContext arg_declaration() throws RecognitionException { + Arg_declarationContext _localctx = new Arg_declarationContext(_ctx, getState()); + enterRule(_localctx, 428, RULE_arg_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2619); + type_(); + setState(2620); + identifier(); + setState(2623); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGNMENT) { + { + setState(2621); + match(ASSIGNMENT); + setState(2622); + expression(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Method_invocationContext extends ParserRuleContext { + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Argument_listContext argument_list() { + return getRuleContext(Argument_listContext.class,0); + } + public Method_invocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_method_invocation; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterMethod_invocation(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitMethod_invocation(this); + } + } + + public final Method_invocationContext method_invocation() throws RecognitionException { + Method_invocationContext _localctx = new Method_invocationContext(_ctx, getState()); + enterRule(_localctx, 430, RULE_method_invocation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2625); + match(OPEN_PARENS); + setState(2627); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << IN) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (OUT - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (VOID - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(2626); + argument_list(); + } + } + + setState(2629); + match(CLOSE_PARENS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Object_creation_expressionContext extends ParserRuleContext { + public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } + public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } + public Argument_listContext argument_list() { + return getRuleContext(Argument_listContext.class,0); + } + public Object_or_collection_initializerContext object_or_collection_initializer() { + return getRuleContext(Object_or_collection_initializerContext.class,0); + } + public Object_creation_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_object_creation_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterObject_creation_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitObject_creation_expression(this); + } + } + + public final Object_creation_expressionContext object_creation_expression() throws RecognitionException { + Object_creation_expressionContext _localctx = new Object_creation_expressionContext(_ctx, getState()); + enterRule(_localctx, 432, RULE_object_creation_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2631); + match(OPEN_PARENS); + setState(2633); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << IN) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL_ - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (OUT - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (VOID - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { + { + setState(2632); + argument_list(); + } + } + + setState(2635); + match(CLOSE_PARENS); + setState(2637); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACE) { + { + setState(2636); + object_or_collection_initializer(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IdentifierContext extends ParserRuleContext { + public TerminalNode IDENTIFIER() { return getToken(CSharpParser.IDENTIFIER, 0); } + public TerminalNode ADD() { return getToken(CSharpParser.ADD, 0); } + public TerminalNode ALIAS() { return getToken(CSharpParser.ALIAS, 0); } + public TerminalNode ARGLIST() { return getToken(CSharpParser.ARGLIST, 0); } + public TerminalNode ASCENDING() { return getToken(CSharpParser.ASCENDING, 0); } + public TerminalNode ASYNC() { return getToken(CSharpParser.ASYNC, 0); } + public TerminalNode AWAIT() { return getToken(CSharpParser.AWAIT, 0); } + public TerminalNode BY() { return getToken(CSharpParser.BY, 0); } + public TerminalNode DESCENDING() { return getToken(CSharpParser.DESCENDING, 0); } + public TerminalNode DYNAMIC() { return getToken(CSharpParser.DYNAMIC, 0); } + public TerminalNode EQUALS() { return getToken(CSharpParser.EQUALS, 0); } + public TerminalNode FROM() { return getToken(CSharpParser.FROM, 0); } + public TerminalNode GET() { return getToken(CSharpParser.GET, 0); } + public TerminalNode GROUP() { return getToken(CSharpParser.GROUP, 0); } + public TerminalNode INTO() { return getToken(CSharpParser.INTO, 0); } + public TerminalNode JOIN() { return getToken(CSharpParser.JOIN, 0); } + public TerminalNode LET() { return getToken(CSharpParser.LET, 0); } + public TerminalNode NAMEOF() { return getToken(CSharpParser.NAMEOF, 0); } + public TerminalNode ON() { return getToken(CSharpParser.ON, 0); } + public TerminalNode ORDERBY() { return getToken(CSharpParser.ORDERBY, 0); } + public TerminalNode PARTIAL() { return getToken(CSharpParser.PARTIAL, 0); } + public TerminalNode REMOVE() { return getToken(CSharpParser.REMOVE, 0); } + public TerminalNode SELECT() { return getToken(CSharpParser.SELECT, 0); } + public TerminalNode SET() { return getToken(CSharpParser.SET, 0); } + public TerminalNode UNMANAGED() { return getToken(CSharpParser.UNMANAGED, 0); } + public TerminalNode VAR() { return getToken(CSharpParser.VAR, 0); } + public TerminalNode WHEN() { return getToken(CSharpParser.WHEN, 0); } + public TerminalNode WHERE() { return getToken(CSharpParser.WHERE, 0); } + public TerminalNode YIELD() { return getToken(CSharpParser.YIELD, 0); } + public IdentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).enterIdentifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof CSharpParserListener ) ((CSharpParserListener)listener).exitIdentifier(this); + } + } + + public final IdentifierContext identifier() throws RecognitionException { + IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); + enterRule(_localctx, 434, RULE_identifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2639); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + 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 187: + return right_arrow_sempred((Right_arrowContext)_localctx, predIndex); + case 188: + return right_shift_sempred((Right_shiftContext)_localctx, predIndex); + case 189: + return right_shift_assignment_sempred((Right_shift_assignmentContext)_localctx, predIndex); + } + return true; + } + private boolean right_arrow_sempred(Right_arrowContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return (((Right_arrowContext)_localctx).first!=null?((Right_arrowContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_arrowContext)_localctx).second!=null?((Right_arrowContext)_localctx).second.getTokenIndex():0); + } + return true; + } + private boolean right_shift_sempred(Right_shiftContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return (((Right_shiftContext)_localctx).first!=null?((Right_shiftContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_shiftContext)_localctx).second!=null?((Right_shiftContext)_localctx).second.getTokenIndex():0); + } + return true; + } + private boolean right_shift_assignment_sempred(Right_shift_assignmentContext _localctx, int predIndex) { + switch (predIndex) { + case 2: + return (((Right_shift_assignmentContext)_localctx).first!=null?((Right_shift_assignmentContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_shift_assignmentContext)_localctx).second!=null?((Right_shift_assignmentContext)_localctx).second.getTokenIndex():0); + } + return true; + } + + private static final int _serializedATNSegments = 2; + private static final String _serializedATNSegment0 = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00c8\u0a54\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\3\2\5\2\u01b8\n\2\3\2\5\2\u01bb\n\2\3\2\5\2\u01be\n\2"+ + "\3\2\7\2\u01c1\n\2\f\2\16\2\u01c4\13\2\3\2\5\2\u01c7\n\2\3\2\3\2\3\3\3"+ + "\3\5\3\u01cd\n\3\3\3\5\3\u01d0\n\3\3\3\3\3\3\3\5\3\u01d5\n\3\7\3\u01d7"+ + "\n\3\f\3\16\3\u01da\13\3\3\4\3\4\3\4\3\4\7\4\u01e0\n\4\f\4\16\4\u01e3"+ + "\13\4\3\5\3\5\3\5\3\5\3\5\5\5\u01ea\n\5\3\6\3\6\3\6\3\6\6\6\u01f0\n\6"+ + "\r\6\16\6\u01f1\3\6\3\6\3\7\3\7\5\7\u01f8\n\7\3\b\3\b\5\b\u01fc\n\b\3"+ + "\t\3\t\3\t\5\t\u0201\n\t\3\n\3\n\3\13\3\13\3\f\3\f\3\f\3\f\5\f\u020b\n"+ + "\f\3\r\3\r\3\r\3\r\7\r\u0211\n\r\f\r\16\r\u0214\13\r\3\r\3\r\3\16\3\16"+ + "\3\16\7\16\u021b\n\16\f\16\16\16\u021e\13\16\3\17\3\17\3\17\5\17\u0223"+ + "\n\17\3\17\5\17\u0226\n\17\3\17\3\17\5\17\u022a\n\17\3\17\3\17\3\20\3"+ + "\20\3\20\3\20\5\20\u0232\n\20\3\21\3\21\3\21\5\21\u0237\n\21\3\22\3\22"+ + "\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u0241\n\22\3\23\3\23\3\23\3\23\3\23"+ + "\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u024e\n\23\3\24\3\24\3\24\3\24\3\24"+ + "\3\24\5\24\u0256\n\24\3\25\3\25\3\25\3\25\5\25\u025c\n\25\5\25\u025e\n"+ + "\25\3\26\3\26\3\26\7\26\u0263\n\26\f\26\16\26\u0266\13\26\3\27\3\27\3"+ + "\27\7\27\u026b\n\27\f\27\16\27\u026e\13\27\3\30\3\30\3\30\7\30\u0273\n"+ + "\30\f\30\16\30\u0276\13\30\3\31\3\31\3\31\7\31\u027b\n\31\f\31\16\31\u027e"+ + "\13\31\3\32\3\32\3\32\7\32\u0283\n\32\f\32\16\32\u0286\13\32\3\33\3\33"+ + "\3\33\7\33\u028b\n\33\f\33\16\33\u028e\13\33\3\34\3\34\3\34\3\34\3\34"+ + "\3\34\3\34\7\34\u0297\n\34\f\34\16\34\u029a\13\34\3\35\3\35\3\35\5\35"+ + "\u029f\n\35\3\35\7\35\u02a2\n\35\f\35\16\35\u02a5\13\35\3\36\3\36\3\36"+ + "\7\36\u02aa\n\36\f\36\16\36\u02ad\13\36\3\37\3\37\3\37\7\37\u02b2\n\37"+ + "\f\37\16\37\u02b5\13\37\3 \3 \3 \3 \3 \5 \u02bc\n \5 \u02be\n \3 \5 \u02c1"+ + "\n \3!\3!\3!\7!\u02c6\n!\f!\16!\u02c9\13!\3\"\3\"\5\"\u02cd\n\"\3\"\3"+ + "\"\3\"\3#\3#\5#\u02d4\n#\3#\3#\5#\u02d8\n#\5#\u02da\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$\5$\u02f6"+ + "\n$\3%\3%\5%\u02fa\n%\3%\7%\u02fd\n%\f%\16%\u0300\13%\3%\5%\u0303\n%\3"+ + "%\3%\3%\3%\3%\3%\5%\u030b\n%\3%\5%\u030e\n%\3%\7%\u0311\n%\f%\16%\u0314"+ + "\13%\3%\5%\u0317\n%\7%\u0319\n%\f%\16%\u031c\13%\3&\3&\3&\5&\u0321\n&"+ + "\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\5&\u032f\n&\3&\3&\3&\3&\5&\u0335"+ + "\n&\3&\3&\3&\3&\3&\3&\3&\3&\7&\u033f\n&\f&\16&\u0342\13&\3&\5&\u0345\n"+ + "&\3&\6&\u0348\n&\r&\16&\u0349\3&\3&\5&\u034e\n&\3&\3&\3&\3&\5&\u0354\n"+ + "&\3&\3&\3&\3&\6&\u035a\n&\r&\16&\u035b\3&\3&\3&\3&\3&\3&\3&\5&\u0365\n"+ + "&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\5&\u0377\n&\3&\5&\u037a"+ + "\n&\3&\3&\3&\5&\u037f\n&\3&\5&\u0382\n&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&"+ + "\3&\7&\u038f\n&\f&\16&\u0392\13&\3&\3&\3&\5&\u0397\n&\3\'\3\'\5\'\u039b"+ + "\n\'\3(\3(\3(\3)\5)\u03a1\n)\3)\3)\3)\5)\u03a6\n)\3*\5*\u03a9\n*\3*\3"+ + "*\3*\3*\7*\u03af\n*\f*\16*\u03b2\13*\3*\3*\3+\3+\3+\5+\u03b9\n+\3+\3+"+ + "\3,\3,\3-\3-\3-\7-\u03c2\n-\f-\16-\u03c5\13-\3.\3.\5.\u03c9\n.\3/\3/\3"+ + "/\5/\u03ce\n/\5/\u03d0\n/\3/\3/\3\60\3\60\3\60\7\60\u03d7\n\60\f\60\16"+ + "\60\u03da\13\60\3\61\3\61\3\61\3\61\3\61\5\61\u03e1\n\61\3\61\3\61\3\61"+ + "\3\62\3\62\5\62\u03e8\n\62\3\63\3\63\3\63\3\63\7\63\u03ee\n\63\f\63\16"+ + "\63\u03f1\13\63\3\63\5\63\u03f4\n\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64"+ + "\5\64\u03fd\n\64\3\65\3\65\3\65\5\65\u0402\n\65\5\65\u0404\n\65\3\65\3"+ + "\65\3\66\3\66\3\66\7\66\u040b\n\66\f\66\16\66\u040e\13\66\3\67\3\67\3"+ + "\67\3\67\3\67\5\67\u0415\n\67\38\38\58\u0419\n8\38\38\38\58\u041e\n8\5"+ + "8\u0420\n8\38\38\38\58\u0425\n8\78\u0427\n8\f8\168\u042a\138\39\39\79"+ + "\u042e\n9\f9\169\u0431\139\39\39\3:\3:\3:\7:\u0438\n:\f:\16:\u043b\13"+ + ":\3:\5:\u043e\n:\3:\5:\u0441\n:\3:\5:\u0444\n:\3;\3;\3;\3;\7;\u044a\n"+ + ";\f;\16;\u044d\13;\3;\3;\3<\3<\3<\3<\3=\5=\u0456\n=\3=\3=\3=\3=\3>\3>"+ + "\3>\3>\3>\3>\3>\3>\3>\3>\3>\5>\u0467\n>\3?\3?\3?\7?\u046c\n?\f?\16?\u046f"+ + "\13?\3@\5@\u0472\n@\3@\3@\3@\3A\3A\3A\7A\u047a\nA\fA\16A\u047d\13A\3B"+ + "\3B\5B\u0481\nB\3C\3C\3C\3D\3D\5D\u0488\nD\3D\3D\3D\3D\3E\7E\u048f\nE"+ + "\fE\16E\u0492\13E\3E\3E\5E\u0496\nE\3F\3F\3F\3F\3F\5F\u049d\nF\3G\3G\3"+ + "G\3G\3G\3H\3H\3H\3I\3I\5I\u04a9\nI\3I\3I\3I\3I\3I\3I\3I\3I\3I\5I\u04b4"+ + "\nI\3J\3J\3J\3J\7J\u04ba\nJ\fJ\16J\u04bd\13J\3K\3K\5K\u04c1\nK\3L\3L\3"+ + "L\3L\3L\3L\3L\5L\u04ca\nL\3M\3M\3M\3M\3N\3N\3N\5N\u04d3\nN\3O\3O\3O\3"+ + "O\3O\3O\3O\5O\u04dc\nO\3P\3P\3P\3Q\5Q\u04e2\nQ\3Q\3Q\3Q\5Q\u04e7\nQ\3"+ + "Q\3Q\5Q\u04eb\nQ\3Q\3Q\5Q\u04ef\nQ\3R\3R\5R\u04f3\nR\3R\3R\5R\u04f7\n"+ + "R\3S\3S\3S\3S\3S\5S\u04fe\nS\3T\3T\3T\3T\3U\3U\5U\u0506\nU\3V\3V\3V\3"+ + "V\3V\3V\3V\3V\3V\3V\3V\5V\u0513\nV\3V\3V\3V\3V\3V\3V\7V\u051b\nV\fV\16"+ + "V\u051e\13V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\5"+ + "V\u0533\nV\3V\3V\5V\u0537\nV\3V\3V\5V\u053b\nV\3V\3V\3V\5V\u0540\nV\3"+ + "V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\5V\u0554\nV\3V\3"+ + "V\3V\5V\u0559\nV\3V\3V\3V\5V\u055e\nV\3V\3V\3V\3V\3V\5V\u0565\nV\3V\5"+ + "V\u0568\nV\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3"+ + "V\5V\u057e\nV\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\5V\u058a\nV\3W\3W\5W\u058e"+ + "\nW\3W\3W\3X\3X\3X\3X\5X\u0596\nX\3X\3X\3X\3X\7X\u059c\nX\fX\16X\u059f"+ + "\13X\3X\3X\3X\3X\5X\u05a5\nX\3Y\3Y\5Y\u05a9\nY\3Z\3Z\3Z\5Z\u05ae\nZ\3"+ + "Z\5Z\u05b1\nZ\3[\3[\3[\5[\u05b6\n[\3\\\3\\\3\\\3\\\3]\3]\5]\u05be\n]\3"+ + "^\6^\u05c1\n^\r^\16^\u05c2\3^\3^\3_\3_\3_\5_\u05ca\n_\3_\3_\3_\3_\5_\u05d0"+ + "\n_\3`\3`\3`\3a\6a\u05d6\na\ra\16a\u05d7\3b\3b\3b\3b\7b\u05de\nb\fb\16"+ + "b\u05e1\13b\5b\u05e3\nb\3c\3c\3c\7c\u05e8\nc\fc\16c\u05eb\13c\3d\3d\7"+ + "d\u05ef\nd\fd\16d\u05f2\13d\3d\5d\u05f5\nd\3d\5d\u05f8\nd\3e\3e\3e\3e"+ + "\5e\u05fe\ne\3e\3e\5e\u0602\ne\3e\3e\3f\3f\5f\u0608\nf\3f\3f\3g\3g\3g"+ + "\3g\3g\3h\3h\3h\3i\3i\5i\u0616\ni\3j\3j\3j\3j\5j\u061c\nj\3k\3k\3k\7k"+ + "\u0621\nk\fk\16k\u0624\13k\3l\3l\5l\u0628\nl\3l\5l\u062b\nl\3l\5l\u062e"+ + "\nl\3l\3l\3m\6m\u0633\nm\rm\16m\u0634\3n\3n\3n\3n\3n\3o\6o\u063d\no\r"+ + "o\16o\u063e\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\5p\u0650\np\3"+ + "q\6q\u0653\nq\rq\16q\u0654\3r\3r\5r\u0659\nr\3s\5s\u065c\ns\3s\5s\u065f"+ + "\ns\3s\3s\3s\3s\3s\5s\u0666\ns\3t\3t\3t\3t\5t\u066c\nt\3u\3u\3u\3u\7u"+ + "\u0672\nu\fu\16u\u0675\13u\3u\3u\3v\5v\u067a\nv\3v\3v\3w\3w\3w\3w\7w\u0682"+ + "\nw\fw\16w\u0685\13w\3x\3x\3x\7x\u068a\nx\fx\16x\u068d\13x\3y\6y\u0690"+ + "\ny\ry\16y\u0691\3z\3z\3z\3z\3z\3{\3{\3{\3{\5{\u069d\n{\3{\3{\5{\u06a1"+ + "\n{\5{\u06a3\n{\3|\3|\3|\5|\u06a8\n|\3|\3|\5|\u06ac\n|\3}\3}\3}\7}\u06b1"+ + "\n}\f}\16}\u06b4\13}\3~\3~\3~\3~\3\177\3\177\5\177\u06bc\n\177\3\177\3"+ + "\177\3\u0080\6\u0080\u06c1\n\u0080\r\u0080\16\u0080\u06c2\3\u0081\5\u0081"+ + "\u06c6\n\u0081\3\u0081\5\u0081\u06c9\n\u0081\3\u0081\3\u0081\5\u0081\u06cd"+ + "\n\u0081\3\u0082\6\u0082\u06d0\n\u0082\r\u0082\16\u0082\u06d1\3\u0083"+ + "\3\u0083\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084"+ + "\3\u0084\5\u0084\u06df\n\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084"+ + "\3\u0084\3\u0084\3\u0084\5\u0084\u06e9\n\u0084\3\u0085\3\u0085\3\u0085"+ + "\3\u0085\3\u0085\5\u0085\u06f0\n\u0085\3\u0085\3\u0085\3\u0085\3\u0085"+ + "\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\5\u0085\u06fc\n\u0085"+ + "\3\u0086\3\u0086\3\u0086\7\u0086\u0701\n\u0086\f\u0086\16\u0086\u0704"+ + "\13\u0086\3\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\7\u0088"+ + "\u070d\n\u0088\f\u0088\16\u0088\u0710\13\u0088\3\u0089\3\u0089\3\u0089"+ + "\5\u0089\u0715\n\u0089\3\u008a\3\u008a\5\u008a\u0719\n\u008a\3\u008b\3"+ + "\u008b\5\u008b\u071d\n\u008b\3\u008c\3\u008c\3\u008d\3\u008d\5\u008d\u0723"+ + "\n\u008d\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e\u0729\n\u008e\5\u008e"+ + "\u072b\n\u008e\3\u008f\3\u008f\3\u008f\7\u008f\u0730\n\u008f\f\u008f\16"+ + "\u008f\u0733\13\u008f\3\u0090\5\u0090\u0736\n\u0090\3\u0090\5\u0090\u0739"+ + "\n\u0090\3\u0090\3\u0090\5\u0090\u073d\n\u0090\3\u0091\3\u0091\3\u0091"+ + "\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\5\u0091\u0747\n\u0091\3\u0092"+ + "\5\u0092\u074a\n\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0093\5\u0093"+ + "\u0751\n\u0093\3\u0093\5\u0093\u0754\n\u0093\3\u0093\3\u0093\3\u0093\5"+ + "\u0093\u0759\n\u0093\3\u0093\3\u0093\3\u0093\5\u0093\u075e\n\u0093\5\u0093"+ + "\u0760\n\u0093\3\u0094\5\u0094\u0763\n\u0094\3\u0094\5\u0094\u0766\n\u0094"+ + "\3\u0094\3\u0094\3\u0094\3\u0095\5\u0095\u076c\n\u0095\3\u0095\5\u0095"+ + "\u076f\n\u0095\3\u0095\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0096"+ + "\3\u0096\3\u0096\3\u0096\5\u0096\u077b\n\u0096\3\u0097\3\u0097\5\u0097"+ + "\u077f\n\u0097\3\u0098\5\u0098\u0782\n\u0098\3\u0098\3\u0098\3\u0098\3"+ + "\u0098\3\u0098\3\u0098\3\u0098\3\u0098\5\u0098\u078c\n\u0098\3\u0099\5"+ + "\u0099\u078f\n\u0099\3\u0099\3\u0099\3\u0099\3\u009a\5\u009a\u0795\n\u009a"+ + "\3\u009a\3\u009a\3\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b"+ + "\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b"+ + "\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\5\u009b\u07b0"+ + "\n\u009b\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009d"+ + "\3\u009d\3\u009d\3\u009d\5\u009d\u07bd\n\u009d\3\u009d\3\u009d\3\u009e"+ + "\3\u009e\5\u009e\u07c3\n\u009e\3\u009f\3\u009f\3\u009f\3\u00a0\3\u00a0"+ + "\7\u00a0\u07ca\n\u00a0\f\u00a0\16\u00a0\u07cd\13\u00a0\3\u00a0\3\u00a0"+ + "\3\u00a1\5\u00a1\u07d2\n\u00a1\3\u00a1\5\u00a1\u07d5\n\u00a1\3\u00a1\3"+ + "\u00a1\3\u00a1\3\u00a1\6\u00a1\u07db\n\u00a1\r\u00a1\16\u00a1\u07dc\3"+ + "\u00a1\3\u00a1\5\u00a1\u07e1\n\u00a1\3\u00a2\3\u00a2\7\u00a2\u07e5\n\u00a2"+ + "\f\u00a2\16\u00a2\u07e8\13\u00a2\3\u00a2\6\u00a2\u07eb\n\u00a2\r\u00a2"+ + "\16\u00a2\u07ec\3\u00a3\3\u00a3\7\u00a3\u07f1\n\u00a3\f\u00a3\16\u00a3"+ + "\u07f4\13\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a4\7\u00a4"+ + "\u07fc\n\u00a4\f\u00a4\16\u00a4\u07ff\13\u00a4\3\u00a4\5\u00a4\u0802\n"+ + "\u00a4\5\u00a4\u0804\n\u00a4\3\u00a4\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3"+ + "\u00a5\7\u00a5\u080c\n\u00a5\f\u00a5\16\u00a5\u080f\13\u00a5\3\u00a5\3"+ + "\u00a5\3\u00a6\5\u00a6\u0814\n\u00a6\3\u00a6\5\u00a6\u0817\n\u00a6\3\u00a6"+ + "\3\u00a6\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a9\3\u00a9\7\u00a9"+ + "\u0822\n\u00a9\f\u00a9\16\u00a9\u0825\13\u00a9\3\u00a9\3\u00a9\3\u00aa"+ + "\5\u00aa\u082a\n\u00aa\3\u00aa\5\u00aa\u082d\n\u00aa\3\u00aa\5\u00aa\u0830"+ + "\n\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u0837\n\u00aa"+ + "\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u083c\n\u00aa\3\u00aa\3\u00aa\5\u00aa"+ + "\u0840\n\u00aa\3\u00aa\3\u00aa\5\u00aa\u0844\n\u00aa\3\u00aa\3\u00aa\3"+ + "\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa"+ + "\3\u00aa\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u0855\n\u00aa\3\u00aa\5\u00aa"+ + "\u0858\n\u00aa\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u085d\n\u00aa\3\u00aa\3"+ + "\u00aa\5\u00aa\u0861\n\u00aa\3\u00aa\3\u00aa\5\u00aa\u0865\n\u00aa\3\u00aa"+ + "\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u086e\n\u00aa"+ + "\3\u00ab\5\u00ab\u0871\n\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u0876\n"+ + "\u00ab\3\u00ab\3\u00ab\5\u00ab\u087a\n\u00ab\3\u00ab\3\u00ab\3\u00ab\5"+ + "\u00ab\u087f\n\u00ab\3\u00ab\3\u00ab\5\u00ab\u0883\n\u00ab\5\u00ab\u0885"+ + "\n\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ad\7\u00ad"+ + "\u088e\n\u00ad\f\u00ad\16\u00ad\u0891\13\u00ad\3\u00ad\5\u00ad\u0894\n"+ + "\u00ad\5\u00ad\u0896\n\u00ad\3\u00ad\3\u00ad\3\u00ae\5\u00ae\u089b\n\u00ae"+ + "\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u08a0\n\u00ae\3\u00af\3\u00af\3\u00af"+ + "\3\u00af\3\u00af\5\u00af\u08a7\n\u00af\3\u00af\3\u00af\3\u00b0\3\u00b0"+ + "\5\u00b0\u08ad\n\u00b0\3\u00b1\6\u00b1\u08b0\n\u00b1\r\u00b1\16\u00b1"+ + "\u08b1\3\u00b2\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u08b8\n\u00b2\3\u00b2\3"+ + "\u00b2\5\u00b2\u08bc\n\u00b2\3\u00b2\3\u00b2\3\u00b3\3\u00b3\5\u00b3\u08c2"+ + "\n\u00b3\3\u00b4\3\u00b4\3\u00b4\7\u00b4\u08c7\n\u00b4\f\u00b4\16\u00b4"+ + "\u08ca\13\u00b4\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\7\u00b5\u08d1"+ + "\n\u00b5\f\u00b5\16\u00b5\u08d4\13\u00b5\5\u00b5\u08d6\n\u00b5\3\u00b5"+ + "\5\u00b5\u08d9\n\u00b5\3\u00b6\3\u00b6\3\u00b6\5\u00b6\u08de\n\u00b6\3"+ + "\u00b6\3\u00b6\3\u00b7\3\u00b7\5\u00b7\u08e4\n\u00b7\3\u00b7\3\u00b7\7"+ + "\u00b7\u08e8\n\u00b7\f\u00b7\16\u00b7\u08eb\13\u00b7\3\u00b7\3\u00b7\3"+ + "\u00b7\3\u00b7\5\u00b7\u08f1\n\u00b7\3\u00b8\3\u00b8\3\u00b8\7\u00b8\u08f6"+ + "\n\u00b8\f\u00b8\16\u00b8\u08f9\13\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9"+ + "\3\u00ba\5\u00ba\u0900\n\u00ba\3\u00ba\3\u00ba\5\u00ba\u0904\n\u00ba\3"+ + "\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bc\3\u00bc\3\u00bc\3\u00bc"+ + "\3\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u0913\n\u00bc\3\u00bc\3\u00bc"+ + "\5\u00bc\u0917\n\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\7\u00bc"+ + "\u091e\n\u00bc\f\u00bc\16\u00bc\u0921\13\u00bc\3\u00bc\5\u00bc\u0924\n"+ + "\u00bc\3\u00bc\3\u00bc\5\u00bc\u0928\n\u00bc\3\u00bd\3\u00bd\3\u00bd\3"+ + "\u00bd\3\u00be\3\u00be\3\u00be\3\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf"+ + "\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0"+ + "\u093e\n\u00c0\3\u00c1\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2\5\u00c2"+ + "\u0946\n\u00c2\3\u00c3\3\u00c3\7\u00c3\u094a\n\u00c3\f\u00c3\16\u00c3"+ + "\u094d\13\u00c3\3\u00c3\3\u00c3\3\u00c4\3\u00c4\7\u00c4\u0953\n\u00c4"+ + "\f\u00c4\16\u00c4\u0956\13\u00c4\3\u00c4\3\u00c4\3\u00c5\3\u00c5\3\u00c5"+ + "\3\u00c5\5\u00c5\u095e\n\u00c5\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6"+ + "\u0964\n\u00c6\3\u00c7\3\u00c7\3\u00c7\7\u00c7\u0969\n\u00c7\f\u00c7\16"+ + "\u00c7\u096c\13\u00c7\3\u00c7\3\u00c7\6\u00c7\u0970\n\u00c7\r\u00c7\16"+ + "\u00c7\u0971\5\u00c7\u0974\n\u00c7\3\u00c8\3\u00c8\3\u00c9\3\u00c9\3\u00c9"+ + "\5\u00c9\u097b\n\u00c9\3\u00c9\5\u00c9\u097e\n\u00c9\3\u00c9\5\u00c9\u0981"+ + "\n\u00c9\3\u00c9\3\u00c9\5\u00c9\u0985\n\u00c9\3\u00ca\5\u00ca\u0988\n"+ + "\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u098d\n\u00ca\3\u00ca\5\u00ca\u0990"+ + "\n\u00ca\3\u00ca\5\u00ca\u0993\n\u00ca\3\u00ca\3\u00ca\5\u00ca\u0997\n"+ + "\u00ca\3\u00cb\3\u00cb\3\u00cb\5\u00cb\u099c\n\u00cb\3\u00cb\5\u00cb\u099f"+ + "\n\u00cb\3\u00cb\5\u00cb\u09a2\n\u00cb\3\u00cb\3\u00cb\5\u00cb\u09a6\n"+ + "\u00cb\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09ab\n\u00cc\3\u00cc\3\u00cc\5"+ + "\u00cc\u09af\n\u00cc\3\u00cd\3\u00cd\3\u00cd\3\u00cd\5\u00cd\u09b5\n\u00cd"+ + "\3\u00cd\3\u00cd\5\u00cd\u09b9\n\u00cd\3\u00cd\3\u00cd\5\u00cd\u09bd\n"+ + "\u00cd\3\u00cd\3\u00cd\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce"+ + "\3\u00ce\3\u00ce\3\u00ce\3\u00ce\5\u00ce\u09cb\n\u00ce\3\u00cf\3\u00cf"+ + "\3\u00cf\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0"+ + "\5\u00d0\u09d8\n\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\5\u00d0\u09de\n"+ + "\u00d0\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2"+ + "\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2"+ + "\5\u00d2\u09f1\n\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3"+ + "\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09fc\n\u00d4\3\u00d4\3\u00d4\5\u00d4"+ + "\u0a00\n\u00d4\3\u00d4\3\u00d4\3\u00d5\3\u00d5\5\u00d5\u0a06\n\u00d5\3"+ + "\u00d5\3\u00d5\5\u00d5\u0a0a\n\u00d5\3\u00d5\3\u00d5\5\u00d5\u0a0e\n\u00d5"+ + "\3\u00d5\3\u00d5\3\u00d5\3\u00d5\3\u00d5\5\u00d5\u0a15\n\u00d5\3\u00d6"+ + "\3\u00d6\3\u00d6\3\u00d6\3\u00d6\5\u00d6\u0a1c\n\u00d6\3\u00d6\5\u00d6"+ + "\u0a1f\n\u00d6\3\u00d6\3\u00d6\7\u00d6\u0a23\n\u00d6\f\u00d6\16\u00d6"+ + "\u0a26\13\u00d6\3\u00d7\3\u00d7\3\u00d7\3\u00d7\5\u00d7\u0a2c\n\u00d7"+ + "\3\u00d7\3\u00d7\3\u00d7\5\u00d7\u0a31\n\u00d7\3\u00d7\5\u00d7\u0a34\n"+ + "\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\5\u00d7\u0a3c\n"+ + "\u00d7\3\u00d8\3\u00d8\3\u00d8\3\u00d8\5\u00d8\u0a42\n\u00d8\3\u00d9\3"+ + "\u00d9\5\u00d9\u0a46\n\u00d9\3\u00d9\3\u00d9\3\u00da\3\u00da\5\u00da\u0a4c"+ + "\n\u00da\3\u00da\3\u00da\5\u00da\u0a50\n\u00da\3\u00db\3\u00db\3\u00db"+ + "\2\2\u00dc\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\66"+ + "8:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a"+ + "\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2"+ + "\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba"+ + "\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2"+ + "\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea"+ + "\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102"+ + "\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a"+ + "\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132"+ + "\u0134\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a"+ + "\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162"+ + "\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a"+ + "\u017c\u017e\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192"+ + "\u0194\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa"+ + "\u01ac\u01ae\u01b0\u01b2\u01b4\2\25\n\2\27\27\32\3299AAUUYYefjj\4\2$$"+ + "//\5\288JJRR\3\2\u009e\u009f\4\2\u0094\u0095\u00a0\u00a1\3\2\u0089\u008a"+ + "\3\2\u008b\u008d\20\2\24\24\27\27\32\32\37\37$$//99AAFFUUYY]]efjj\4\2"+ + "\20\20\"\"\4\2\21\21ii\16\2\13\13\21\21++;;DDKKMQVV\\\\iimmoo\4\2**\67"+ + "\67\4\2\23\23``\4\2\u008b\u008b\u0096\u0096\4\288JJ\4\2,,bb\25\2\13\13"+ + "\17\17\23\25\27!#$&\')\61\64\64\66;==@ACFHHJLNRTVYkmorr\3\2QR\26\2\f\16"+ + "\20\22\26\26\"\"%%((\62\63\65\65<<>?BBGGIIMMSSWXhhllpqst\2\u0b62\2\u01b7"+ + "\3\2\2\2\4\u01cf\3\2\2\2\6\u01db\3\2\2\2\b\u01e9\3\2\2\2\n\u01eb\3\2\2"+ + "\2\f\u01f5\3\2\2\2\16\u01fb\3\2\2\2\20\u0200\3\2\2\2\22\u0202\3\2\2\2"+ + "\24\u0204\3\2\2\2\26\u020a\3\2\2\2\30\u020c\3\2\2\2\32\u0217\3\2\2\2\34"+ + "\u0222\3\2\2\2\36\u0231\3\2\2\2 \u0236\3\2\2\2\"\u0240\3\2\2\2$\u024d"+ + "\3\2\2\2&\u024f\3\2\2\2(\u0257\3\2\2\2*\u025f\3\2\2\2,\u0267\3\2\2\2."+ + "\u026f\3\2\2\2\60\u0277\3\2\2\2\62\u027f\3\2\2\2\64\u0287\3\2\2\2\66\u028f"+ + "\3\2\2\28\u029b\3\2\2\2:\u02a6\3\2\2\2<\u02ae\3\2\2\2>\u02b6\3\2\2\2@"+ + "\u02c2\3\2\2\2B\u02ca\3\2\2\2D\u02d9\3\2\2\2F\u02f5\3\2\2\2H\u02f7\3\2"+ + "\2\2J\u0396\3\2\2\2L\u039a\3\2\2\2N\u039c\3\2\2\2P\u03a0\3\2\2\2R\u03a8"+ + "\3\2\2\2T\u03b8\3\2\2\2V\u03bc\3\2\2\2X\u03be\3\2\2\2Z\u03c8\3\2\2\2\\"+ + "\u03ca\3\2\2\2^\u03d3\3\2\2\2`\u03e0\3\2\2\2b\u03e7\3\2\2\2d\u03e9\3\2"+ + "\2\2f\u03fc\3\2\2\2h\u03fe\3\2\2\2j\u0407\3\2\2\2l\u0414\3\2\2\2n\u0416"+ + "\3\2\2\2p\u042b\3\2\2\2r\u0434\3\2\2\2t\u0445\3\2\2\2v\u0450\3\2\2\2x"+ + "\u0455\3\2\2\2z\u0466\3\2\2\2|\u0468\3\2\2\2~\u0471\3\2\2\2\u0080\u0476"+ + "\3\2\2\2\u0082\u0480\3\2\2\2\u0084\u0482\3\2\2\2\u0086\u0485\3\2\2\2\u0088"+ + "\u0490\3\2\2\2\u008a\u049c\3\2\2\2\u008c\u049e\3\2\2\2\u008e\u04a3\3\2"+ + "\2\2\u0090\u04a6\3\2\2\2\u0092\u04b5\3\2\2\2\u0094\u04be\3\2\2\2\u0096"+ + "\u04c9\3\2\2\2\u0098\u04cb\3\2\2\2\u009a\u04d2\3\2\2\2\u009c\u04db\3\2"+ + "\2\2\u009e\u04dd\3\2\2\2\u00a0\u04e1\3\2\2\2\u00a2\u04f6\3\2\2\2\u00a4"+ + "\u04fd\3\2\2\2\u00a6\u04ff\3\2\2\2\u00a8\u0505\3\2\2\2\u00aa\u0589\3\2"+ + "\2\2\u00ac\u058b\3\2\2\2\u00ae\u05a4\3\2\2\2\u00b0\u05a8\3\2\2\2\u00b2"+ + "\u05aa\3\2\2\2\u00b4\u05b5\3\2\2\2\u00b6\u05b7\3\2\2\2\u00b8\u05bd\3\2"+ + "\2\2\u00ba\u05c0\3\2\2\2\u00bc\u05cf\3\2\2\2\u00be\u05d1\3\2\2\2\u00c0"+ + "\u05d5\3\2\2\2\u00c2\u05e2\3\2\2\2\u00c4\u05e4\3\2\2\2\u00c6\u05f7\3\2"+ + "\2\2\u00c8\u05f9\3\2\2\2\u00ca\u0605\3\2\2\2\u00cc\u060b\3\2\2\2\u00ce"+ + "\u0610\3\2\2\2\u00d0\u0615\3\2\2\2\u00d2\u0617\3\2\2\2\u00d4\u061d\3\2"+ + "\2\2\u00d6\u0625\3\2\2\2\u00d8\u0632\3\2\2\2\u00da\u0636\3\2\2\2\u00dc"+ + "\u063c\3\2\2\2\u00de\u064f\3\2\2\2\u00e0\u0652\3\2\2\2\u00e2\u0658\3\2"+ + "\2\2\u00e4\u065b\3\2\2\2\u00e6\u0667\3\2\2\2\u00e8\u066d\3\2\2\2\u00ea"+ + "\u0679\3\2\2\2\u00ec\u067d\3\2\2\2\u00ee\u0686\3\2\2\2\u00f0\u068f\3\2"+ + "\2\2\u00f2\u0693\3\2\2\2\u00f4\u06a2\3\2\2\2\u00f6\u06ab\3\2\2\2\u00f8"+ + "\u06ad\3\2\2\2\u00fa\u06b5\3\2\2\2\u00fc\u06b9\3\2\2\2\u00fe\u06c0\3\2"+ + "\2\2\u0100\u06c5\3\2\2\2\u0102\u06cf\3\2\2\2\u0104\u06d3\3\2\2\2\u0106"+ + "\u06e8\3\2\2\2\u0108\u06ef\3\2\2\2\u010a\u06fd\3\2\2\2\u010c\u0705\3\2"+ + "\2\2\u010e\u0709\3\2\2\2\u0110\u0711\3\2\2\2\u0112\u0718\3\2\2\2\u0114"+ + "\u071c\3\2\2\2\u0116\u071e\3\2\2\2\u0118\u0722\3\2\2\2\u011a\u072a\3\2"+ + "\2\2\u011c\u072c\3\2\2\2\u011e\u073c\3\2\2\2\u0120\u0746\3\2\2\2\u0122"+ + "\u0749\3\2\2\2\u0124\u0750\3\2\2\2\u0126\u0762\3\2\2\2\u0128\u076b\3\2"+ + "\2\2\u012a\u077a\3\2\2\2\u012c\u077e\3\2\2\2\u012e\u0781\3\2\2\2\u0130"+ + "\u078e\3\2\2\2\u0132\u0794\3\2\2\2\u0134\u07af\3\2\2\2\u0136\u07b1\3\2"+ + "\2\2\u0138\u07b8\3\2\2\2\u013a\u07c2\3\2\2\2\u013c\u07c4\3\2\2\2\u013e"+ + "\u07c7\3\2\2\2\u0140\u07d1\3\2\2\2\u0142\u07e2\3\2\2\2\u0144\u07ee\3\2"+ + "\2\2\u0146\u07f7\3\2\2\2\u0148\u0807\3\2\2\2\u014a\u0813\3\2\2\2\u014c"+ + "\u081a\3\2\2\2\u014e\u081c\3\2\2\2\u0150\u081f\3\2\2\2\u0152\u0829\3\2"+ + "\2\2\u0154\u0870\3\2\2\2\u0156\u0886\3\2\2\2\u0158\u0889\3\2\2\2\u015a"+ + "\u089a\3\2\2\2\u015c\u08a1\3\2\2\2\u015e\u08ac\3\2\2\2\u0160\u08af\3\2"+ + "\2\2\u0162\u08b3\3\2\2\2\u0164\u08c1\3\2\2\2\u0166\u08c3\3\2\2\2\u0168"+ + "\u08cb\3\2\2\2\u016a\u08dd\3\2\2\2\u016c\u08f0\3\2\2\2\u016e\u08f2\3\2"+ + "\2\2\u0170\u08fa\3\2\2\2\u0172\u0903\3\2\2\2\u0174\u0905\3\2\2\2\u0176"+ + "\u0927\3\2\2\2\u0178\u0929\3\2\2\2\u017a\u092d\3\2\2\2\u017c\u0931\3\2"+ + "\2\2\u017e\u093d\3\2\2\2\u0180\u093f\3\2\2\2\u0182\u0945\3\2\2\2\u0184"+ + "\u0947\3\2\2\2\u0186\u0950\3\2\2\2\u0188\u095d\3\2\2\2\u018a\u0963\3\2"+ + "\2\2\u018c\u0965\3\2\2\2\u018e\u0975\3\2\2\2\u0190\u0977\3\2\2\2\u0192"+ + "\u0987\3\2\2\2\u0194\u0998\3\2\2\2\u0196\u09a7\3\2\2\2\u0198\u09b0\3\2"+ + "\2\2\u019a\u09c0\3\2\2\2\u019c\u09cc\3\2\2\2\u019e\u09cf\3\2\2\2\u01a0"+ + "\u09df\3\2\2\2\u01a2\u09e4\3\2\2\2\u01a4\u09f2\3\2\2\2\u01a6\u09f8\3\2"+ + "\2\2\u01a8\u0a03\3\2\2\2\u01aa\u0a1b\3\2\2\2\u01ac\u0a27\3\2\2\2\u01ae"+ + "\u0a3d\3\2\2\2\u01b0\u0a43\3\2\2\2\u01b2\u0a49\3\2\2\2\u01b4\u0a51\3\2"+ + "\2\2\u01b6\u01b8\7\3\2\2\u01b7\u01b6\3\2\2\2\u01b7\u01b8\3\2\2\2\u01b8"+ + "\u01ba\3\2\2\2\u01b9\u01bb\5\u00d8m\2\u01ba\u01b9\3\2\2\2\u01ba\u01bb"+ + "\3\2\2\2\u01bb\u01bd\3\2\2\2\u01bc\u01be\5\u00dco\2\u01bd\u01bc\3\2\2"+ + "\2\u01bd\u01be\3\2\2\2\u01be\u01c2\3\2\2\2\u01bf\u01c1\5\u015c\u00af\2"+ + "\u01c0\u01bf\3\2\2\2\u01c1\u01c4\3\2\2\2\u01c2\u01c0\3\2\2\2\u01c2\u01c3"+ + "\3\2\2\2\u01c3\u01c6\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c5\u01c7\5\u00e0q"+ + "\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01c9"+ + "\7\2\2\3\u01c9\3\3\2\2\2\u01ca\u01cc\5\u01b4\u00db\2\u01cb\u01cd\5\30"+ + "\r\2\u01cc\u01cb\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01d0\3\2\2\2\u01ce"+ + "\u01d0\5\u00e6t\2\u01cf\u01ca\3\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d8"+ + "\3\2\2\2\u01d1\u01d2\7\u0085\2\2\u01d2\u01d4\5\u01b4\u00db\2\u01d3\u01d5"+ + "\5\30\r\2\u01d4\u01d3\3\2\2\2\u01d4\u01d5\3\2\2\2\u01d5\u01d7\3\2\2\2"+ + "\u01d6\u01d1\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d8\u01d9"+ + "\3\2\2\2\u01d9\5\3\2\2\2\u01da\u01d8\3\2\2\2\u01db\u01e1\5\b\5\2\u01dc"+ + "\u01e0\7\u0096\2\2\u01dd\u01e0\5\u0144\u00a3\2\u01de\u01e0\7\u008b\2\2"+ + "\u01df\u01dc\3\2\2\2\u01df\u01dd\3\2\2\2\u01df\u01de\3\2\2\2\u01e0\u01e3"+ + "\3\2\2\2\u01e1\u01df\3\2\2\2\u01e1\u01e2\3\2\2\2\u01e2\7\3\2\2\2\u01e3"+ + "\u01e1\3\2\2\2\u01e4\u01ea\5\16\b\2\u01e5\u01ea\5\26\f\2\u01e6\u01e7\7"+ + "n\2\2\u01e7\u01ea\7\u008b\2\2\u01e8\u01ea\5\n\6\2\u01e9\u01e4\3\2\2\2"+ + "\u01e9\u01e5\3\2\2\2\u01e9\u01e6\3\2\2\2\u01e9\u01e8\3\2\2\2\u01ea\t\3"+ + "\2\2\2\u01eb\u01ec\7\u0083\2\2\u01ec\u01ef\5\f\7\2\u01ed\u01ee\7\u0086"+ + "\2\2\u01ee\u01f0\5\f\7\2\u01ef\u01ed\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1"+ + "\u01ef\3\2\2\2\u01f1\u01f2\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3\u01f4\7\u0084"+ + "\2\2\u01f4\13\3\2\2\2\u01f5\u01f7\5\6\4\2\u01f6\u01f8\5\u01b4\u00db\2"+ + "\u01f7\u01f6\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8\r\3\2\2\2\u01f9\u01fc\5"+ + "\20\t\2\u01fa\u01fc\7\24\2\2\u01fb\u01f9\3\2\2\2\u01fb\u01fa\3\2\2\2\u01fc"+ + "\17\3\2\2\2\u01fd\u0201\5\22\n\2\u01fe\u0201\5\24\13\2\u01ff\u0201\7\37"+ + "\2\2\u0200\u01fd\3\2\2\2\u0200\u01fe\3\2\2\2\u0200\u01ff\3\2\2\2\u0201"+ + "\21\3\2\2\2\u0202\u0203\t\2\2\2\u0203\23\3\2\2\2\u0204\u0205\t\3\2\2\u0205"+ + "\25\3\2\2\2\u0206\u020b\5\4\3\2\u0207\u020b\7F\2\2\u0208\u020b\7%\2\2"+ + "\u0209\u020b\7]\2\2\u020a\u0206\3\2\2\2\u020a\u0207\3\2\2\2\u020a\u0208"+ + "\3\2\2\2\u020a\u0209\3\2\2\2\u020b\27\3\2\2\2\u020c\u020d\7\u0094\2\2"+ + "\u020d\u0212\5\6\4\2\u020e\u020f\7\u0086\2\2\u020f\u0211\5\6\4\2\u0210"+ + "\u020e\3\2\2\2\u0211\u0214\3\2\2\2\u0212\u0210\3\2\2\2\u0212\u0213\3\2"+ + "\2\2\u0213\u0215\3\2\2\2\u0214\u0212\3\2\2\2\u0215\u0216\7\u0095\2\2\u0216"+ + "\31\3\2\2\2\u0217\u021c\5\34\17\2\u0218\u0219\7\u0086\2\2\u0219\u021b"+ + "\5\34\17\2\u021a\u0218\3\2\2\2\u021b\u021e\3\2\2\2\u021c\u021a\3\2\2\2"+ + "\u021c\u021d\3\2\2\2\u021d\33\3\2\2\2\u021e\u021c\3\2\2\2\u021f\u0220"+ + "\5\u01b4\u00db\2\u0220\u0221\7\u0087\2\2\u0221\u0223\3\2\2\2\u0222\u021f"+ + "\3\2\2\2\u0222\u0223\3\2\2\2\u0223\u0225\3\2\2\2\u0224\u0226\t\4\2\2\u0225"+ + "\u0224\3\2\2\2\u0225\u0226\3\2\2\2\u0226\u0229\3\2\2\2\u0227\u022a\7l"+ + "\2\2\u0228\u022a\5\6\4\2\u0229\u0227\3\2\2\2\u0229\u0228\3\2\2\2\u0229"+ + "\u022a\3\2\2\2\u022a\u022b\3\2\2\2\u022b\u022c\5\36\20\2\u022c\35\3\2"+ + "\2\2\u022d\u0232\5\"\22\2\u022e\u0232\5 \21\2\u022f\u0230\7R\2\2\u0230"+ + "\u0232\5 \21\2\u0231\u022d\3\2\2\2\u0231\u022e\3\2\2\2\u0231\u022f\3\2"+ + "\2\2\u0232\37\3\2\2\2\u0233\u0237\5x=\2\u0234\u0237\5\u0084C\2\u0235\u0237"+ + "\5&\24\2\u0236\u0233\3\2\2\2\u0236\u0234\3\2\2\2\u0236\u0235\3\2\2\2\u0237"+ + "!\3\2\2\2\u0238\u0239\5F$\2\u0239\u023a\5$\23\2\u023a\u023b\5\36\20\2"+ + "\u023b\u0241\3\2\2\2\u023c\u023d\5F$\2\u023d\u023e\7\u00ac\2\2\u023e\u023f"+ + "\5L\'\2\u023f\u0241\3\2\2\2\u0240\u0238\3\2\2\2\u0240\u023c\3\2\2\2\u0241"+ + "#\3\2\2\2\u0242\u024e\7\u0093\2\2\u0243\u024e\7\u00a2\2\2\u0244\u024e"+ + "\7\u00a3\2\2\u0245\u024e\7\u00a4\2\2\u0246\u024e\7\u00a5\2\2\u0247\u024e"+ + "\7\u00a6\2\2\u0248\u024e\7\u00a7\2\2\u0249\u024e\7\u00a8\2\2\u024a\u024e"+ + "\7\u00a9\2\2\u024b\u024e\7\u00ab\2\2\u024c\u024e\5\u017c\u00bf\2\u024d"+ + "\u0242\3\2\2\2\u024d\u0243\3\2\2\2\u024d\u0244\3\2\2\2\u024d\u0245\3\2"+ + "\2\2\u024d\u0246\3\2\2\2\u024d\u0247\3\2\2\2\u024d\u0248\3\2\2\2\u024d"+ + "\u0249\3\2\2\2\u024d\u024a\3\2\2\2\u024d\u024b\3\2\2\2\u024d\u024c\3\2"+ + "\2\2\u024e%\3\2\2\2\u024f\u0255\5(\25\2\u0250\u0251\7\u0096\2\2\u0251"+ + "\u0252\5L\'\2\u0252\u0253\7\u0087\2\2\u0253\u0254\5L\'\2\u0254\u0256\3"+ + "\2\2\2\u0255\u0250\3\2\2\2\u0255\u0256\3\2\2\2\u0256\'\3\2\2\2\u0257\u025d"+ + "\5*\26\2\u0258\u025b\7\u0098\2\2\u0259\u025c\5(\25\2\u025a\u025c\5N(\2"+ + "\u025b\u0259\3\2\2\2\u025b\u025a\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u0258"+ + "\3\2\2\2\u025d\u025e\3\2\2\2\u025e)\3\2\2\2\u025f\u0264\5,\27\2\u0260"+ + "\u0261\7\u009c\2\2\u0261\u0263\5,\27\2\u0262\u0260\3\2\2\2\u0263\u0266"+ + "\3\2\2\2\u0264\u0262\3\2\2\2\u0264\u0265\3\2\2\2\u0265+\3\2\2\2\u0266"+ + "\u0264\3\2\2\2\u0267\u026c\5.\30\2\u0268\u0269\7\u009b\2\2\u0269\u026b"+ + "\5.\30\2\u026a\u0268\3\2\2\2\u026b\u026e\3\2\2\2\u026c\u026a\3\2\2\2\u026c"+ + "\u026d\3\2\2\2\u026d-\3\2\2\2\u026e\u026c\3\2\2\2\u026f\u0274\5\60\31"+ + "\2\u0270\u0271\7\u008f\2\2\u0271\u0273\5\60\31\2\u0272\u0270\3\2\2\2\u0273"+ + "\u0276\3\2\2\2\u0274\u0272\3\2\2\2\u0274\u0275\3\2\2\2\u0275/\3\2\2\2"+ + "\u0276\u0274\3\2\2\2\u0277\u027c\5\62\32\2\u0278\u0279\7\u0090\2\2\u0279"+ + "\u027b\5\62\32\2\u027a\u0278\3\2\2\2\u027b\u027e\3\2\2\2\u027c\u027a\3"+ + "\2\2\2\u027c\u027d\3\2\2\2\u027d\61\3\2\2\2\u027e\u027c\3\2\2\2\u027f"+ + "\u0284\5\64\33\2\u0280\u0281\7\u008e\2\2\u0281\u0283\5\64\33\2\u0282\u0280"+ + "\3\2\2\2\u0283\u0286\3\2\2\2\u0284\u0282\3\2\2\2\u0284\u0285\3\2\2\2\u0285"+ + "\63\3\2\2\2\u0286\u0284\3\2\2\2\u0287\u028c\5\66\34\2\u0288\u0289\t\5"+ + "\2\2\u0289\u028b\5\66\34\2\u028a\u0288\3\2\2\2\u028b\u028e\3\2\2\2\u028c"+ + "\u028a\3\2\2\2\u028c\u028d\3\2\2\2\u028d\65\3\2\2\2\u028e\u028c\3\2\2"+ + "\2\u028f\u0298\58\35\2\u0290\u0291\t\6\2\2\u0291\u0297\58\35\2\u0292\u0293"+ + "\7=\2\2\u0293\u0297\5r:\2\u0294\u0295\7\17\2\2\u0295\u0297\5\6\4\2\u0296"+ + "\u0290\3\2\2\2\u0296\u0292\3\2\2\2\u0296\u0294\3\2\2\2\u0297\u029a\3\2"+ + "\2\2\u0298\u0296\3\2\2\2\u0298\u0299\3\2\2\2\u0299\67\3\2\2\2\u029a\u0298"+ + "\3\2\2\2\u029b\u02a3\5:\36\2\u029c\u029f\7\u00aa\2\2\u029d\u029f\5\u017a"+ + "\u00be\2\u029e\u029c\3\2\2\2\u029e\u029d\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0"+ + "\u02a2\5:\36\2\u02a1\u029e\3\2\2\2\u02a2\u02a5\3\2\2\2\u02a3\u02a1\3\2"+ + "\2\2\u02a3\u02a4\3\2\2\2\u02a49\3\2\2\2\u02a5\u02a3\3\2\2\2\u02a6\u02ab"+ + "\5<\37\2\u02a7\u02a8\t\7\2\2\u02a8\u02aa\5<\37\2\u02a9\u02a7\3\2\2\2\u02aa"+ + "\u02ad\3\2\2\2\u02ab\u02a9\3\2\2\2\u02ab\u02ac\3\2\2\2\u02ac;\3\2\2\2"+ + "\u02ad\u02ab\3\2\2\2\u02ae\u02b3\5> \2\u02af\u02b0\t\b\2\2\u02b0\u02b2"+ + "\5> \2\u02b1\u02af\3\2\2\2\u02b2\u02b5\3\2\2\2\u02b3\u02b1\3\2\2\2\u02b3"+ + "\u02b4\3\2\2\2\u02b4=\3\2\2\2\u02b5\u02b3\3\2\2\2\u02b6\u02c0\5D#\2\u02b7"+ + "\u02b8\7_\2\2\u02b8\u02bd\7\177\2\2\u02b9\u02bb\5@!\2\u02ba\u02bc\7\u0086"+ + "\2\2\u02bb\u02ba\3\2\2\2\u02bb\u02bc\3\2\2\2\u02bc\u02be\3\2\2\2\u02bd"+ + "\u02b9\3\2\2\2\u02bd\u02be\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c1\7\u0080"+ + "\2\2\u02c0\u02b7\3\2\2\2\u02c0\u02c1\3\2\2\2\u02c1?\3\2\2\2\u02c2\u02c7"+ + "\5B\"\2\u02c3\u02c4\7\u0086\2\2\u02c4\u02c6\5B\"\2\u02c5\u02c3\3\2\2\2"+ + "\u02c6\u02c9\3\2\2\2\u02c7\u02c5\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8A\3"+ + "\2\2\2\u02c9\u02c7\3\2\2\2\u02ca\u02cc\5\36\20\2\u02cb\u02cd\5\u00be`"+ + "\2\u02cc\u02cb\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd\u02ce\3\2\2\2\u02ce\u02cf"+ + "\5\u0178\u00bd\2\u02cf\u02d0\5L\'\2\u02d0C\3\2\2\2\u02d1\u02da\5F$\2\u02d2"+ + "\u02d4\5F$\2\u02d3\u02d2\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4\u02d5\3\2\2"+ + "\2\u02d5\u02d7\7\u00ad\2\2\u02d6\u02d8\5F$\2\u02d7\u02d6\3\2\2\2\u02d7"+ + "\u02d8\3\2\2\2\u02d8\u02da\3\2\2\2\u02d9\u02d1\3\2\2\2\u02d9\u02d3\3\2"+ + "\2\2\u02daE\3\2\2\2\u02db\u02f6\5H%\2\u02dc\u02dd\7\u0089\2\2\u02dd\u02f6"+ + "\5F$\2\u02de\u02df\7\u008a\2\2\u02df\u02f6\5F$\2\u02e0\u02e1\7\u0091\2"+ + "\2\u02e1\u02f6\5F$\2\u02e2\u02e3\7\u0092\2\2\u02e3\u02f6\5F$\2\u02e4\u02e5"+ + "\7\u0099\2\2\u02e5\u02f6\5F$\2\u02e6\u02e7\7\u009a\2\2\u02e7\u02f6\5F"+ + "$\2\u02e8\u02e9\7\u0083\2\2\u02e9\u02ea\5\6\4\2\u02ea\u02eb\7\u0084\2"+ + "\2\u02eb\u02ec\5F$\2\u02ec\u02f6\3\2\2\2\u02ed\u02ee\7\22\2\2\u02ee\u02f6"+ + "\5F$\2\u02ef\u02f0\7\u008e\2\2\u02f0\u02f6\5F$\2\u02f1\u02f2\7\u008b\2"+ + "\2\u02f2\u02f6\5F$\2\u02f3\u02f4\7\u0090\2\2\u02f4\u02f6\5F$\2\u02f5\u02db"+ + "\3\2\2\2\u02f5\u02dc\3\2\2\2\u02f5\u02de\3\2\2\2\u02f5\u02e0\3\2\2\2\u02f5"+ + "\u02e2\3\2\2\2\u02f5\u02e4\3\2\2\2\u02f5\u02e6\3\2\2\2\u02f5\u02e8\3\2"+ + "\2\2\u02f5\u02ed\3\2\2\2\u02f5\u02ef\3\2\2\2\u02f5\u02f1\3\2\2\2\u02f5"+ + "\u02f3\3\2\2\2\u02f6G\3\2\2\2\u02f7\u02f9\5J&\2\u02f8\u02fa\7\u0091\2"+ + "\2\u02f9\u02f8\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa\u02fe\3\2\2\2\u02fb\u02fd"+ + "\5R*\2\u02fc\u02fb\3\2\2\2\u02fd\u0300\3\2\2\2\u02fe\u02fc\3\2\2\2\u02fe"+ + "\u02ff\3\2\2\2\u02ff\u0302\3\2\2\2\u0300\u02fe\3\2\2\2\u0301\u0303\7\u0091"+ + "\2\2\u0302\u0301\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u031a\3\2\2\2\u0304"+ + "\u030b\5P)\2\u0305\u030b\5\u01b0\u00d9\2\u0306\u030b\7\u0099\2\2\u0307"+ + "\u030b\7\u009a\2\2\u0308\u0309\7\u009d\2\2\u0309\u030b\5\u01b4\u00db\2"+ + "\u030a\u0304\3\2\2\2\u030a\u0305\3\2\2\2\u030a\u0306\3\2\2\2\u030a\u0307"+ + "\3\2\2\2\u030a\u0308\3\2\2\2\u030b\u030d\3\2\2\2\u030c\u030e\7\u0091\2"+ + "\2\u030d\u030c\3\2\2\2\u030d\u030e\3\2\2\2\u030e\u0312\3\2\2\2\u030f\u0311"+ + "\5R*\2\u0310\u030f\3\2\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312"+ + "\u0313\3\2\2\2\u0313\u0316\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0317\7\u0091"+ + "\2\2\u0316\u0315\3\2\2\2\u0316\u0317\3\2\2\2\u0317\u0319\3\2\2\2\u0318"+ + "\u030a\3\2\2\2\u0319\u031c\3\2\2\2\u031a\u0318\3\2\2\2\u031a\u031b\3\2"+ + "\2\2\u031bI\3\2\2\2\u031c\u031a\3\2\2\2\u031d\u0397\5\u017e\u00c0\2\u031e"+ + "\u0320\5\u01b4\u00db\2\u031f\u0321\5\30\r\2\u0320\u031f\3\2\2\2\u0320"+ + "\u0321\3\2\2\2\u0321\u0397\3\2\2\2\u0322\u0323\7\u0083\2\2\u0323\u0324"+ + "\5\36\20\2\u0324\u0325\7\u0084\2\2\u0325\u0397\3\2\2\2\u0326\u0397\5V"+ + ",\2\u0327\u0397\5\u00e6t\2\u0328\u0397\7u\2\2\u0329\u0397\7`\2\2\u032a"+ + "\u0334\7\23\2\2\u032b\u032c\7\u0085\2\2\u032c\u032e\5\u01b4\u00db\2\u032d"+ + "\u032f\5\30\r\2\u032e\u032d\3\2\2\2\u032e\u032f\3\2\2\2\u032f\u0335\3"+ + "\2\2\2\u0330\u0331\7\u0081\2\2\u0331\u0332\5X-\2\u0332\u0333\7\u0082\2"+ + "\2\u0333\u0335\3\2\2\2\u0334\u032b\3\2\2\2\u0334\u0330\3\2\2\2\u0335\u0397"+ + "\3\2\2\2\u0336\u0353\7D\2\2\u0337\u034d\5\6\4\2\u0338\u034e\5\u01b2\u00da"+ + "\2\u0339\u034e\5Z.\2\u033a\u033b\7\u0081\2\2\u033b\u033c\5X-\2\u033c\u0340"+ + "\7\u0082\2\2\u033d\u033f\5\u0144\u00a3\2\u033e\u033d\3\2\2\2\u033f\u0342"+ + "\3\2\2\2\u0340\u033e\3\2\2\2\u0340\u0341\3\2\2\2\u0341\u0344\3\2\2\2\u0342"+ + "\u0340\3\2\2\2\u0343\u0345\5\u0146\u00a4\2\u0344\u0343\3\2\2\2\u0344\u0345"+ + "\3\2\2\2\u0345\u034e\3\2\2\2\u0346\u0348\5\u0144\u00a3\2\u0347\u0346\3"+ + "\2\2\2\u0348\u0349\3\2\2\2\u0349\u0347\3\2\2\2\u0349\u034a\3\2\2\2\u034a"+ + "\u034b\3\2\2\2\u034b\u034c\5\u0146\u00a4\2\u034c\u034e\3\2\2\2\u034d\u0338"+ + "\3\2\2\2\u034d\u0339\3\2\2\2\u034d\u033a\3\2\2\2\u034d\u0347\3\2\2\2\u034e"+ + "\u0354\3\2\2\2\u034f\u0354\5h\65\2\u0350\u0351\5\u0144\u00a3\2\u0351\u0352"+ + "\5\u0146\u00a4\2\u0352\u0354\3\2\2\2\u0353\u0337\3\2\2\2\u0353\u034f\3"+ + "\2\2\2\u0353\u0350\3\2\2\2\u0354\u0397\3\2\2\2\u0355\u0356\7\u0083\2\2"+ + "\u0356\u0359\5\34\17\2\u0357\u0358\7\u0086\2\2\u0358\u035a\5\34\17\2\u0359"+ + "\u0357\3\2\2\2\u035a\u035b\3\2\2\2\u035b\u0359\3\2\2\2\u035b\u035c\3\2"+ + "\2\2\u035c\u035d\3\2\2\2\u035d\u035e\7\u0084\2\2\u035e\u0397\3\2\2\2\u035f"+ + "\u0360\7d\2\2\u0360\u0364\7\u0083\2\2\u0361\u0365\5n8\2\u0362\u0365\5"+ + "\6\4\2\u0363\u0365\7n\2\2\u0364\u0361\3\2\2\2\u0364\u0362\3\2\2\2\u0364"+ + "\u0363\3\2\2\2\u0365\u0366\3\2\2\2\u0366\u0397\7\u0084\2\2\u0367\u0368"+ + "\7\33\2\2\u0368\u0369\7\u0083\2\2\u0369\u036a\5\36\20\2\u036a\u036b\7"+ + "\u0084\2\2\u036b\u0397\3\2\2\2\u036c\u036d\7g\2\2\u036d\u036e\7\u0083"+ + "\2\2\u036e\u036f\5\36\20\2\u036f\u0370\7\u0084\2\2\u0370\u0397\3\2\2\2"+ + "\u0371\u0376\7 \2\2\u0372\u0373\7\u0083\2\2\u0373\u0374\5\6\4\2\u0374"+ + "\u0375\7\u0084\2\2\u0375\u0377\3\2\2\2\u0376\u0372\3\2\2\2\u0376\u0377"+ + "\3\2\2\2\u0377\u0397\3\2\2\2\u0378\u037a\7\21\2\2\u0379\u0378\3\2\2\2"+ + "\u0379\u037a\3\2\2\2\u037a\u037b\3\2\2\2\u037b\u0381\7!\2\2\u037c\u037e"+ + "\7\u0083\2\2\u037d\u037f\5|?\2\u037e\u037d\3\2\2\2\u037e\u037f\3\2\2\2"+ + "\u037f\u0380\3\2\2\2\u0380\u0382\7\u0084\2\2\u0381\u037c\3\2\2\2\u0381"+ + "\u0382\3\2\2\2\u0382\u0383\3\2\2\2\u0383\u0397\5\u00acW\2\u0384\u0385"+ + "\7Z\2\2\u0385\u0386\7\u0083\2\2\u0386\u0387\5\6\4\2\u0387\u0388\7\u0084"+ + "\2\2\u0388\u0397\3\2\2\2\u0389\u038a\7B\2\2\u038a\u0390\7\u0083\2\2\u038b"+ + "\u038c\5\u01b4\u00db\2\u038c\u038d\7\u0085\2\2\u038d\u038f\3\2\2\2\u038e"+ + "\u038b\3\2\2\2\u038f\u0392\3\2\2\2\u0390\u038e\3\2\2\2\u0390\u0391\3\2"+ + "\2\2\u0391\u0393\3\2\2\2\u0392\u0390\3\2\2\2\u0393\u0394\5\u01b4\u00db"+ + "\2\u0394\u0395\7\u0084\2\2\u0395\u0397\3\2\2\2\u0396\u031d\3\2\2\2\u0396"+ + "\u031e\3\2\2\2\u0396\u0322\3\2\2\2\u0396\u0326\3\2\2\2\u0396\u0327\3\2"+ + "\2\2\u0396\u0328\3\2\2\2\u0396\u0329\3\2\2\2\u0396\u032a\3\2\2\2\u0396"+ + "\u0336\3\2\2\2\u0396\u0355\3\2\2\2\u0396\u035f\3\2\2\2\u0396\u0367\3\2"+ + "\2\2\u0396\u036c\3\2\2\2\u0396\u0371\3\2\2\2\u0396\u0379\3\2\2\2\u0396"+ + "\u0384\3\2\2\2\u0396\u0389\3\2\2\2\u0397K\3\2\2\2\u0398\u039b\5\36\20"+ + "\2\u0399\u039b\5N(\2\u039a\u0398\3\2\2\2\u039a\u0399\3\2\2\2\u039bM\3"+ + "\2\2\2\u039c\u039d\7a\2\2\u039d\u039e\5\36\20\2\u039eO\3\2\2\2\u039f\u03a1"+ + "\7\u0096\2\2\u03a0\u039f\3\2\2\2\u03a0\u03a1\3\2\2\2\u03a1\u03a2\3\2\2"+ + "\2\u03a2\u03a3\7\u0085\2\2\u03a3\u03a5\5\u01b4\u00db\2\u03a4\u03a6\5\30"+ + "\r\2\u03a5\u03a4\3\2\2\2\u03a5\u03a6\3\2\2\2\u03a6Q\3\2\2\2\u03a7\u03a9"+ + "\7\u0096\2\2\u03a8\u03a7\3\2\2\2\u03a8\u03a9\3\2\2\2\u03a9\u03aa\3\2\2"+ + "\2\u03aa\u03ab\7\u0081\2\2\u03ab\u03b0\5T+\2\u03ac\u03ad\7\u0086\2\2\u03ad"+ + "\u03af\5T+\2\u03ae\u03ac\3\2\2\2\u03af\u03b2\3\2\2\2\u03b0\u03ae\3\2\2"+ + "\2\u03b0\u03b1\3\2\2\2\u03b1\u03b3\3\2\2\2\u03b2\u03b0\3\2\2\2\u03b3\u03b4"+ + "\7\u0082\2\2\u03b4S\3\2\2\2\u03b5\u03b6\5\u01b4\u00db\2\u03b6\u03b7\7"+ + "\u0087\2\2\u03b7\u03b9\3\2\2\2\u03b8\u03b5\3\2\2\2\u03b8\u03b9\3\2\2\2"+ + "\u03b9\u03ba\3\2\2\2\u03ba\u03bb\5\36\20\2\u03bbU\3\2\2\2\u03bc\u03bd"+ + "\t\t\2\2\u03bdW\3\2\2\2\u03be\u03c3\5\36\20\2\u03bf\u03c0\7\u0086\2\2"+ + "\u03c0\u03c2\5\36\20\2\u03c1\u03bf\3\2\2\2\u03c2\u03c5\3\2\2\2\u03c3\u03c1"+ + "\3\2\2\2\u03c3\u03c4\3\2\2\2\u03c4Y\3\2\2\2\u03c5\u03c3\3\2\2\2\u03c6"+ + "\u03c9\5\\/\2\u03c7\u03c9\5d\63\2\u03c8\u03c6\3\2\2\2\u03c8\u03c7\3\2"+ + "\2\2\u03c9[\3\2\2\2\u03ca\u03cf\7\177\2\2\u03cb\u03cd\5^\60\2\u03cc\u03ce"+ + "\7\u0086\2\2\u03cd\u03cc\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u03d0\3\2\2"+ + "\2\u03cf\u03cb\3\2\2\2\u03cf\u03d0\3\2\2\2\u03d0\u03d1\3\2\2\2\u03d1\u03d2"+ + "\7\u0080\2\2\u03d2]\3\2\2\2\u03d3\u03d8\5`\61\2\u03d4\u03d5\7\u0086\2"+ + "\2\u03d5\u03d7\5`\61\2\u03d6\u03d4\3\2\2\2\u03d7\u03da\3\2\2\2\u03d8\u03d6"+ + "\3\2\2\2\u03d8\u03d9\3\2\2\2\u03d9_\3\2\2\2\u03da\u03d8\3\2\2\2\u03db"+ + "\u03e1\5\u01b4\u00db\2\u03dc\u03dd\7\u0081\2\2\u03dd\u03de\5\36\20\2\u03de"+ + "\u03df\7\u0082\2\2\u03df\u03e1\3\2\2\2\u03e0\u03db\3\2\2\2\u03e0\u03dc"+ + "\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2\u03e3\7\u0093\2\2\u03e3\u03e4\5b\62"+ + "\2\u03e4a\3\2\2\2\u03e5\u03e8\5\36\20\2\u03e6\u03e8\5Z.\2\u03e7\u03e5"+ + "\3\2\2\2\u03e7\u03e6\3\2\2\2\u03e8c\3\2\2\2\u03e9\u03ea\7\177\2\2\u03ea"+ + "\u03ef\5f\64\2\u03eb\u03ec\7\u0086\2\2\u03ec\u03ee\5f\64\2\u03ed\u03eb"+ + "\3\2\2\2\u03ee\u03f1\3\2\2\2\u03ef\u03ed\3\2\2\2\u03ef\u03f0\3\2\2\2\u03f0"+ + "\u03f3\3\2\2\2\u03f1\u03ef\3\2\2\2\u03f2\u03f4\7\u0086\2\2\u03f3\u03f2"+ + "\3\2\2\2\u03f3\u03f4\3\2\2\2\u03f4\u03f5\3\2\2\2\u03f5\u03f6\7\u0080\2"+ + "\2\u03f6e\3\2\2\2\u03f7\u03fd\5 \21\2\u03f8\u03f9\7\177\2\2\u03f9\u03fa"+ + "\5X-\2\u03fa\u03fb\7\u0080\2\2\u03fb\u03fd\3\2\2\2\u03fc\u03f7\3\2\2\2"+ + "\u03fc\u03f8\3\2\2\2\u03fdg\3\2\2\2\u03fe\u0403\7\177\2\2\u03ff\u0401"+ + "\5j\66\2\u0400\u0402\7\u0086\2\2\u0401\u0400\3\2\2\2\u0401\u0402\3\2\2"+ + "\2\u0402\u0404\3\2\2\2\u0403\u03ff\3\2\2\2\u0403\u0404\3\2\2\2\u0404\u0405"+ + "\3\2\2\2\u0405\u0406\7\u0080\2\2\u0406i\3\2\2\2\u0407\u040c\5l\67\2\u0408"+ + "\u0409\7\u0086\2\2\u0409\u040b\5l\67\2\u040a\u0408\3\2\2\2\u040b\u040e"+ + "\3\2\2\2\u040c\u040a\3\2\2\2\u040c\u040d\3\2\2\2\u040dk\3\2\2\2\u040e"+ + "\u040c\3\2\2\2\u040f\u0415\5H%\2\u0410\u0411\5\u01b4\u00db\2\u0411\u0412"+ + "\7\u0093\2\2\u0412\u0413\5\36\20\2\u0413\u0415\3\2\2\2\u0414\u040f\3\2"+ + "\2\2\u0414\u0410\3\2\2\2\u0415m\3\2\2\2\u0416\u041f\5\u01b4\u00db\2\u0417"+ + "\u0419\5p9\2\u0418\u0417\3\2\2\2\u0418\u0419\3\2\2\2\u0419\u0420\3\2\2"+ + "\2\u041a\u041b\7\u0097\2\2\u041b\u041d\5\u01b4\u00db\2\u041c\u041e\5p"+ + "9\2\u041d\u041c\3\2\2\2\u041d\u041e\3\2\2\2\u041e\u0420\3\2\2\2\u041f"+ + "\u0418\3\2\2\2\u041f\u041a\3\2\2\2\u0420\u0428\3\2\2\2\u0421\u0422\7\u0085"+ + "\2\2\u0422\u0424\5\u01b4\u00db\2\u0423\u0425\5p9\2\u0424\u0423\3\2\2\2"+ + "\u0424\u0425\3\2\2\2\u0425\u0427\3\2\2\2\u0426\u0421\3\2\2\2\u0427\u042a"+ + "\3\2\2\2\u0428\u0426\3\2\2\2\u0428\u0429\3\2\2\2\u0429o\3\2\2\2\u042a"+ + "\u0428\3\2\2\2\u042b\u042f\7\u0094\2\2\u042c\u042e\7\u0086\2\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\7\u0095\2\2\u0433q\3\2"+ + "\2\2\u0434\u0439\5\b\5\2\u0435\u0438\5\u0144\u00a3\2\u0436\u0438\7\u008b"+ + "\2\2\u0437\u0435\3\2\2\2\u0437\u0436\3\2\2\2\u0438\u043b\3\2\2\2\u0439"+ + "\u0437\3\2\2\2\u0439\u043a\3\2\2\2\u043a\u043d\3\2\2\2\u043b\u0439\3\2"+ + "\2\2\u043c\u043e\7\u0096\2\2\u043d\u043c\3\2\2\2\u043d\u043e\3\2\2\2\u043e"+ + "\u0440\3\2\2\2\u043f\u0441\5t;\2\u0440\u043f\3\2\2\2\u0440\u0441\3\2\2"+ + "\2\u0441\u0443\3\2\2\2\u0442\u0444\5\u01b4\u00db\2\u0443\u0442\3\2\2\2"+ + "\u0443\u0444\3\2\2\2\u0444s\3\2\2\2\u0445\u0446\7\177\2\2\u0446\u044b"+ + "\5v<\2\u0447\u0448\7\u0086\2\2\u0448\u044a\5v<\2\u0449\u0447\3\2\2\2\u044a"+ + "\u044d\3\2\2\2\u044b\u0449\3\2\2\2\u044b\u044c\3\2\2\2\u044c\u044e\3\2"+ + "\2\2\u044d\u044b\3\2\2\2\u044e\u044f\7\u0080\2\2\u044fu\3\2\2\2\u0450"+ + "\u0451\5\u01b4\u00db\2\u0451\u0452\7\u0087\2\2\u0452\u0453\5\36\20\2\u0453"+ + "w\3\2\2\2\u0454\u0456\7\21\2\2\u0455\u0454\3\2\2\2\u0455\u0456\3\2\2\2"+ + "\u0456\u0457\3\2\2\2\u0457\u0458\5z>\2\u0458\u0459\5\u0178\u00bd\2\u0459"+ + "\u045a\5\u0082B\2\u045ay\3\2\2\2\u045b\u045c\7\u0083\2\2\u045c\u0467\7"+ + "\u0084\2\2\u045d\u045e\7\u0083\2\2\u045e\u045f\5|?\2\u045f\u0460\7\u0084"+ + "\2\2\u0460\u0467\3\2\2\2\u0461\u0462\7\u0083\2\2\u0462\u0463\5\u0080A"+ + "\2\u0463\u0464\7\u0084\2\2\u0464\u0467\3\2\2\2\u0465\u0467\5\u01b4\u00db"+ + "\2\u0466\u045b\3\2\2\2\u0466\u045d\3\2\2\2\u0466\u0461\3\2\2\2\u0466\u0465"+ + "\3\2\2\2\u0467{\3\2\2\2\u0468\u046d\5~@\2\u0469\u046a\7\u0086\2\2\u046a"+ + "\u046c\5~@\2\u046b\u0469\3\2\2\2\u046c\u046f\3\2\2\2\u046d\u046b\3\2\2"+ + "\2\u046d\u046e\3\2\2\2\u046e}\3\2\2\2\u046f\u046d\3\2\2\2\u0470\u0472"+ + "\t\4\2\2\u0471\u0470\3\2\2\2\u0471\u0472\3\2\2\2\u0472\u0473\3\2\2\2\u0473"+ + "\u0474\5\6\4\2\u0474\u0475\5\u01b4\u00db\2\u0475\177\3\2\2\2\u0476\u047b"+ + "\5\u01b4\u00db\2\u0477\u0478\7\u0086\2\2\u0478\u047a\5\u01b4\u00db\2\u0479"+ + "\u0477\3\2\2\2\u047a\u047d\3\2\2\2\u047b\u0479\3\2\2\2\u047b\u047c\3\2"+ + "\2\2\u047c\u0081\3\2\2\2\u047d\u047b\3\2\2\2\u047e\u0481\5L\'\2\u047f"+ + "\u0481\5\u00acW\2\u0480\u047e\3\2\2\2\u0480\u047f\3\2\2\2\u0481\u0083"+ + "\3\2\2\2\u0482\u0483\5\u0086D\2\u0483\u0484\5\u0088E\2\u0484\u0085\3\2"+ + "\2\2\u0485\u0487\7\62\2\2\u0486\u0488\5\6\4\2\u0487\u0486\3\2\2\2\u0487"+ + "\u0488\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u048a\5\u01b4\u00db\2\u048a\u048b"+ + "\78\2\2\u048b\u048c\5\36\20\2\u048c\u0087\3\2\2\2\u048d\u048f\5\u008a"+ + "F\2\u048e\u048d\3\2\2\2\u048f\u0492\3\2\2\2\u0490\u048e\3\2\2\2\u0490"+ + "\u0491\3\2\2\2\u0491\u0493\3\2\2\2\u0492\u0490\3\2\2\2\u0493\u0495\5\u0096"+ + "L\2\u0494\u0496\5\u0098M\2\u0495\u0494\3\2\2\2\u0495\u0496\3\2\2\2\u0496"+ + "\u0089\3\2\2\2\u0497\u049d\5\u0086D\2\u0498\u049d\5\u008cG\2\u0499\u049d"+ + "\5\u008eH\2\u049a\u049d\5\u0090I\2\u049b\u049d\5\u0092J\2\u049c\u0497"+ + "\3\2\2\2\u049c\u0498\3\2\2\2\u049c\u0499\3\2\2\2\u049c\u049a\3\2\2\2\u049c"+ + "\u049b\3\2\2\2\u049d\u008b\3\2\2\2\u049e\u049f\7?\2\2\u049f\u04a0\5\u01b4"+ + "\u00db\2\u04a0\u04a1\7\u0093\2\2\u04a1\u04a2\5\36\20\2\u04a2\u008d\3\2"+ + "\2\2\u04a3\u04a4\7q\2\2\u04a4\u04a5\5\36\20\2\u04a5\u008f\3\2\2\2\u04a6"+ + "\u04a8\7>\2\2\u04a7\u04a9\5\6\4\2\u04a8\u04a7\3\2\2\2\u04a8\u04a9\3\2"+ + "\2\2\u04a9\u04aa\3\2\2\2\u04aa\u04ab\5\u01b4\u00db\2\u04ab\u04ac\78\2"+ + "\2\u04ac\u04ad\5\36\20\2\u04ad\u04ae\7G\2\2\u04ae\u04af\5\36\20\2\u04af"+ + "\u04b0\7(\2\2\u04b0\u04b3\5\36\20\2\u04b1\u04b2\7<\2\2\u04b2\u04b4\5\u01b4"+ + "\u00db\2\u04b3\u04b1\3\2\2\2\u04b3\u04b4\3\2\2\2\u04b4\u0091\3\2\2\2\u04b5"+ + "\u04b6\7I\2\2\u04b6\u04bb\5\u0094K\2\u04b7\u04b8\7\u0086\2\2\u04b8\u04ba"+ + "\5\u0094K\2\u04b9\u04b7\3\2\2\2\u04ba\u04bd\3\2\2\2\u04bb\u04b9\3\2\2"+ + "\2\u04bb\u04bc\3\2\2\2\u04bc\u0093\3\2\2\2\u04bd\u04bb\3\2\2\2\u04be\u04c0"+ + "\5\36\20\2\u04bf\u04c1\t\n\2\2\u04c0\u04bf\3\2\2\2\u04c0\u04c1\3\2\2\2"+ + "\u04c1\u0095\3\2\2\2\u04c2\u04c3\7W\2\2\u04c3\u04ca\5\36\20\2\u04c4\u04c5"+ + "\7\65\2\2\u04c5\u04c6\5\36\20\2\u04c6\u04c7\7\26\2\2\u04c7\u04c8\5\36"+ + "\20\2\u04c8\u04ca\3\2\2\2\u04c9\u04c2\3\2\2\2\u04c9\u04c4\3\2\2\2\u04ca"+ + "\u0097\3\2\2\2\u04cb\u04cc\7<\2\2\u04cc\u04cd\5\u01b4\u00db\2\u04cd\u04ce"+ + "\5\u0088E\2\u04ce\u0099\3\2\2\2\u04cf\u04d3\5\u00a6T\2\u04d0\u04d3\5\u009c"+ + "O\2\u04d1\u04d3\5\u00a8U\2\u04d2\u04cf\3\2\2\2\u04d2\u04d0\3\2\2\2\u04d2"+ + "\u04d1\3\2\2\2\u04d3\u009b\3\2\2\2\u04d4\u04d5\5\u00aeX\2\u04d5\u04d6"+ + "\7\u0088\2\2\u04d6\u04dc\3\2\2\2\u04d7\u04d8\5\u00b6\\\2\u04d8\u04d9\7"+ + "\u0088\2\2\u04d9\u04dc\3\2\2\2\u04da\u04dc\5\u009eP\2\u04db\u04d4\3\2"+ + "\2\2\u04db\u04d7\3\2\2\2\u04db\u04da\3\2\2\2\u04dc\u009d\3\2\2\2\u04dd"+ + "\u04de\5\u00a0Q\2\u04de\u04df\5\u00a4S\2\u04df\u009f\3\2\2\2\u04e0\u04e2"+ + "\5\u00a2R\2\u04e1\u04e0\3\2\2\2\u04e1\u04e2\3\2\2\2\u04e2\u04e3\3\2\2"+ + "\2\u04e3\u04e4\5\u0114\u008b\2\u04e4\u04e6\5\u01b4\u00db\2\u04e5\u04e7"+ + "\5\u00e8u\2\u04e6\u04e5\3\2\2\2\u04e6\u04e7\3\2\2\2\u04e7\u04e8\3\2\2"+ + "\2\u04e8\u04ea\7\u0083\2\2\u04e9\u04eb\5\u011a\u008e\2\u04ea\u04e9\3\2"+ + "\2\2\u04ea\u04eb\3\2\2\2\u04eb\u04ec\3\2\2\2\u04ec\u04ee\7\u0084\2\2\u04ed"+ + "\u04ef\5\u00f0y\2\u04ee\u04ed\3\2\2\2\u04ee\u04ef\3\2\2\2\u04ef\u00a1"+ + "\3\2\2\2\u04f0\u04f2\t\13\2\2\u04f1\u04f3\7\\\2\2\u04f2\u04f1\3\2\2\2"+ + "\u04f2\u04f3\3\2\2\2\u04f3\u04f7\3\2\2\2\u04f4\u04f5\7\\\2\2\u04f5\u04f7"+ + "\t\13\2\2\u04f6\u04f0\3\2\2\2\u04f6\u04f4\3\2\2\2\u04f7\u00a3\3\2\2\2"+ + "\u04f8\u04fe\5\u00acW\2\u04f9\u04fa\5\u0178\u00bd\2\u04fa\u04fb\5L\'\2"+ + "\u04fb\u04fc\7\u0088\2\2\u04fc\u04fe\3\2\2\2\u04fd\u04f8\3\2\2\2\u04fd"+ + "\u04f9\3\2\2\2\u04fe\u00a5\3\2\2\2\u04ff\u0500\5\u01b4\u00db\2\u0500\u0501"+ + "\7\u0087\2\2\u0501\u0502\5\u009aN\2\u0502\u00a7\3\2\2\2\u0503\u0506\5"+ + "\u00acW\2\u0504\u0506\5\u00aaV\2\u0505\u0503\3\2\2\2\u0505\u0504\3\2\2"+ + "\2\u0506\u00a9\3\2\2\2\u0507\u058a\7\u0088\2\2\u0508\u0509\5\36\20\2\u0509"+ + "\u050a\7\u0088\2\2\u050a\u058a\3\2\2\2\u050b\u050c\7\66\2\2\u050c\u050d"+ + "\7\u0083\2\2\u050d\u050e\5\36\20\2\u050e\u050f\7\u0084\2\2\u050f\u0512"+ + "\5\u00b8]\2\u0510\u0511\7&\2\2\u0511\u0513\5\u00b8]\2\u0512\u0510\3\2"+ + "\2\2\u0512\u0513\3\2\2\2\u0513\u058a\3\2\2\2\u0514\u0515\7_\2\2\u0515"+ + "\u0516\7\u0083\2\2\u0516\u0517\5\36\20\2\u0517\u0518\7\u0084\2\2\u0518"+ + "\u051c\7\177\2\2\u0519\u051b\5\u00ba^\2\u051a\u0519\3\2\2\2\u051b\u051e"+ + "\3\2\2\2\u051c\u051a\3\2\2\2\u051c\u051d\3\2\2\2\u051d\u051f\3\2\2\2\u051e"+ + "\u051c\3\2\2\2\u051f\u0520\7\u0080\2\2\u0520\u058a\3\2\2\2\u0521\u0522"+ + "\7r\2\2\u0522\u0523\7\u0083\2\2\u0523\u0524\5\36\20\2\u0524\u0525\7\u0084"+ + "\2\2\u0525\u0526\5\u00a8U\2\u0526\u058a\3\2\2\2\u0527\u0528\7#\2\2\u0528"+ + "\u0529\5\u00a8U\2\u0529\u052a\7r\2\2\u052a\u052b\7\u0083\2\2\u052b\u052c"+ + "\5\36\20\2\u052c\u052d\7\u0084\2\2\u052d\u052e\7\u0088\2\2\u052e\u058a"+ + "\3\2\2\2\u052f\u0530\7\60\2\2\u0530\u0532\7\u0083\2\2\u0531\u0533\5\u00c2"+ + "b\2\u0532\u0531\3\2\2\2\u0532\u0533\3\2\2\2\u0533\u0534\3\2\2\2\u0534"+ + "\u0536\7\u0088\2\2\u0535\u0537\5\36\20\2\u0536\u0535\3\2\2\2\u0536\u0537"+ + "\3\2\2\2\u0537\u0538\3\2\2\2\u0538\u053a\7\u0088\2\2\u0539\u053b\5\u00c4"+ + "c\2\u053a\u0539\3\2\2\2\u053a\u053b\3\2\2\2\u053b\u053c\3\2\2\2\u053c"+ + "\u053d\7\u0084\2\2\u053d\u058a\5\u00a8U\2\u053e\u0540\7\22\2\2\u053f\u053e"+ + "\3\2\2\2\u053f\u0540\3\2\2\2\u0540\u0541\3\2\2\2\u0541\u0542\7\61\2\2"+ + "\u0542\u0543\7\u0083\2\2\u0543\u0544\5\u00b0Y\2\u0544\u0545\5\u01b4\u00db"+ + "\2\u0545\u0546\78\2\2\u0546\u0547\5\36\20\2\u0547\u0548\7\u0084\2\2\u0548"+ + "\u0549\5\u00a8U\2\u0549\u058a\3\2\2\2\u054a\u054b\7\25\2\2\u054b\u058a"+ + "\7\u0088\2\2\u054c\u054d\7\36\2\2\u054d\u058a\7\u0088\2\2\u054e\u0553"+ + "\7\64\2\2\u054f\u0554\5\u01b4\u00db\2\u0550\u0551\7\30\2\2\u0551\u0554"+ + "\5\36\20\2\u0552\u0554\7 \2\2\u0553\u054f\3\2\2\2\u0553\u0550\3\2\2\2"+ + "\u0553\u0552\3\2\2\2\u0554\u0555\3\2\2\2\u0555\u058a\7\u0088\2\2\u0556"+ + "\u0558\7T\2\2\u0557\u0559\5\36\20\2\u0558\u0557\3\2\2\2\u0558\u0559\3"+ + "\2\2\2\u0559\u055a\3\2\2\2\u055a\u058a\7\u0088\2\2\u055b\u055d\7a\2\2"+ + "\u055c\u055e\5\36\20\2\u055d\u055c\3\2\2\2\u055d\u055e\3\2\2\2\u055e\u055f"+ + "\3\2\2\2\u055f\u058a\7\u0088\2\2\u0560\u0561\7c\2\2\u0561\u0567\5\u00ac"+ + "W\2\u0562\u0564\5\u00c6d\2\u0563\u0565\5\u00ceh\2\u0564\u0563\3\2\2\2"+ + "\u0564\u0565\3\2\2\2\u0565\u0568\3\2\2\2\u0566\u0568\5\u00ceh\2\u0567"+ + "\u0562\3\2\2\2\u0567\u0566\3\2\2\2\u0568\u058a\3\2\2\2\u0569\u056a\7\33"+ + "\2\2\u056a\u058a\5\u00acW\2\u056b\u056c\7g\2\2\u056c\u058a\5\u00acW\2"+ + "\u056d\u056e\7@\2\2\u056e\u056f\7\u0083\2\2\u056f\u0570\5\36\20\2\u0570"+ + "\u0571\7\u0084\2\2\u0571\u0572\5\u00a8U\2\u0572\u058a\3\2\2\2\u0573\u0574"+ + "\7k\2\2\u0574\u0575\7\u0083\2\2\u0575\u0576\5\u00d0i\2\u0576\u0577\7\u0084"+ + "\2\2\u0577\u0578\5\u00a8U\2\u0578\u058a\3\2\2\2\u0579\u057d\7s\2\2\u057a"+ + "\u057b\7T\2\2\u057b\u057e\5\36\20\2\u057c\u057e\7\25\2\2\u057d\u057a\3"+ + "\2\2\2\u057d\u057c\3\2\2\2\u057e\u057f\3\2\2\2\u057f\u058a\7\u0088\2\2"+ + "\u0580\u0581\7i\2\2\u0581\u058a\5\u00acW\2\u0582\u0583\7.\2\2\u0583\u0584"+ + "\7\u0083\2\2\u0584\u0585\5\u016c\u00b7\2\u0585\u0586\5\u016e\u00b8\2\u0586"+ + "\u0587\7\u0084\2\2\u0587\u0588\5\u00a8U\2\u0588\u058a\3\2\2\2\u0589\u0507"+ + "\3\2\2\2\u0589\u0508\3\2\2\2\u0589\u050b\3\2\2\2\u0589\u0514\3\2\2\2\u0589"+ + "\u0521\3\2\2\2\u0589\u0527\3\2\2\2\u0589\u052f\3\2\2\2\u0589\u053f\3\2"+ + "\2\2\u0589\u054a\3\2\2\2\u0589\u054c\3\2\2\2\u0589\u054e\3\2\2\2\u0589"+ + "\u0556\3\2\2\2\u0589\u055b\3\2\2\2\u0589\u0560\3\2\2\2\u0589\u0569\3\2"+ + "\2\2\u0589\u056b\3\2\2\2\u0589\u056d\3\2\2\2\u0589\u0573\3\2\2\2\u0589"+ + "\u0579\3\2\2\2\u0589\u0580\3\2\2\2\u0589\u0582\3\2\2\2\u058a\u00ab\3\2"+ + "\2\2\u058b\u058d\7\177\2\2\u058c\u058e\5\u00c0a\2\u058d\u058c\3\2\2\2"+ + "\u058d\u058e\3\2\2\2\u058e\u058f\3\2\2\2\u058f\u0590\7\u0080\2\2\u0590"+ + "\u00ad\3\2\2\2\u0591\u0596\7k\2\2\u0592\u0596\7R\2\2\u0593\u0594\7R\2"+ + "\2\u0594\u0596\7Q\2\2\u0595\u0591\3\2\2\2\u0595\u0592\3\2\2\2\u0595\u0593"+ + "\3\2\2\2\u0595\u0596\3\2\2\2\u0596\u0597\3\2\2\2\u0597\u0598\5\u00b0Y"+ + "\2\u0598\u059d\5\u00b2Z\2\u0599\u059a\7\u0086\2\2\u059a\u059c\5\u00b2"+ + "Z\2\u059b\u0599\3\2\2\2\u059c\u059f\3\2\2\2\u059d\u059b\3\2\2\2\u059d"+ + "\u059e\3\2\2\2\u059e\u05a5\3\2\2\2\u059f\u059d\3\2\2\2\u05a0\u05a1\7."+ + "\2\2\u05a1\u05a2\5\u016c\u00b7\2\u05a2\u05a3\5\u016e\u00b8\2\u05a3\u05a5"+ + "\3\2\2\2\u05a4\u0595\3\2\2\2\u05a4\u05a0\3\2\2\2\u05a5\u00af\3\2\2\2\u05a6"+ + "\u05a9\7l\2\2\u05a7\u05a9\5\6\4\2\u05a8\u05a6\3\2\2\2\u05a8\u05a7\3\2"+ + "\2\2\u05a9\u00b1\3\2\2\2\u05aa\u05b0\5\u01b4\u00db\2\u05ab\u05ad\7\u0093"+ + "\2\2\u05ac\u05ae\7R\2\2\u05ad\u05ac\3\2\2\2\u05ad\u05ae\3\2\2\2\u05ae"+ + "\u05af\3\2\2\2\u05af\u05b1\5\u00b4[\2\u05b0\u05ab\3\2\2\2\u05b0\u05b1"+ + "\3\2\2\2\u05b1\u00b3\3\2\2\2\u05b2\u05b6\5\36\20\2\u05b3\u05b6\5\u0146"+ + "\u00a4\2\u05b4\u05b6\5\u0176\u00bc\2\u05b5\u05b2\3\2\2\2\u05b5\u05b3\3"+ + "\2\2\2\u05b5\u05b4\3\2\2\2\u05b6\u00b5\3\2\2\2\u05b7\u05b8\7\35\2\2\u05b8"+ + "\u05b9\5\6\4\2\u05b9\u05ba\5\u010a\u0086\2\u05ba\u00b7\3\2\2\2\u05bb\u05be"+ + "\5\u00acW\2\u05bc\u05be\5\u00aaV\2\u05bd\u05bb\3\2\2\2\u05bd\u05bc\3\2"+ + "\2\2\u05be\u00b9\3\2\2\2\u05bf\u05c1\5\u00bc_\2\u05c0\u05bf\3\2\2\2\u05c1"+ + "\u05c2\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3\u05c4\3\2"+ + "\2\2\u05c4\u05c5\5\u00c0a\2\u05c5\u00bb\3\2\2\2\u05c6\u05c7\7\30\2\2\u05c7"+ + "\u05c9\5\36\20\2\u05c8\u05ca\5\u00be`\2\u05c9\u05c8\3\2\2\2\u05c9\u05ca"+ + "\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05cc\7\u0087\2\2\u05cc\u05d0\3\2\2"+ + "\2\u05cd\u05ce\7 \2\2\u05ce\u05d0\7\u0087\2\2\u05cf\u05c6\3\2\2\2\u05cf"+ + "\u05cd\3\2\2\2\u05d0\u00bd\3\2\2\2\u05d1\u05d2\7p\2\2\u05d2\u05d3\5\36"+ + "\20\2\u05d3\u00bf\3\2\2\2\u05d4\u05d6\5\u009aN\2\u05d5\u05d4\3\2\2\2\u05d6"+ + "\u05d7\3\2\2\2\u05d7\u05d5\3\2\2\2\u05d7\u05d8\3\2\2\2\u05d8\u00c1\3\2"+ + "\2\2\u05d9\u05e3\5\u00aeX\2\u05da\u05df\5\36\20\2\u05db\u05dc\7\u0086"+ + "\2\2\u05dc\u05de\5\36\20\2\u05dd\u05db\3\2\2\2\u05de\u05e1\3\2\2\2\u05df"+ + "\u05dd\3\2\2\2\u05df\u05e0\3\2\2\2\u05e0\u05e3\3\2\2\2\u05e1\u05df\3\2"+ + "\2\2\u05e2\u05d9\3\2\2\2\u05e2\u05da\3\2\2\2\u05e3\u00c3\3\2\2\2\u05e4"+ + "\u05e9\5\36\20\2\u05e5\u05e6\7\u0086\2\2\u05e6\u05e8\5\36\20\2\u05e7\u05e5"+ + "\3\2\2\2\u05e8\u05eb\3\2\2\2\u05e9\u05e7\3\2\2\2\u05e9\u05ea\3\2\2\2\u05ea"+ + "\u00c5\3\2\2\2\u05eb\u05e9\3\2\2\2\u05ec\u05f0\5\u00c8e\2\u05ed\u05ef"+ + "\5\u00c8e\2\u05ee\u05ed\3\2\2\2\u05ef\u05f2\3\2\2\2\u05f0\u05ee\3\2\2"+ + "\2\u05f0\u05f1\3\2\2\2\u05f1\u05f4\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f3\u05f5"+ + "\5\u00caf\2\u05f4\u05f3\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5\u05f8\3\2\2"+ + "\2\u05f6\u05f8\5\u00caf\2\u05f7\u05ec\3\2\2\2\u05f7\u05f6\3\2\2\2\u05f8"+ + "\u00c7\3\2\2\2\u05f9\u05fa\7\31\2\2\u05fa\u05fb\7\u0083\2\2\u05fb\u05fd"+ + "\5\26\f\2\u05fc\u05fe\5\u01b4\u00db\2\u05fd\u05fc\3\2\2\2\u05fd\u05fe"+ + "\3\2\2\2\u05fe\u05ff\3\2\2\2\u05ff\u0601\7\u0084\2\2\u0600\u0602\5\u00cc"+ + "g\2\u0601\u0600\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0603\3\2\2\2\u0603"+ + "\u0604\5\u00acW\2\u0604\u00c9\3\2\2\2\u0605\u0607\7\31\2\2\u0606\u0608"+ + "\5\u00ccg\2\u0607\u0606\3\2\2\2\u0607\u0608\3\2\2\2\u0608\u0609\3\2\2"+ + "\2\u0609\u060a\5\u00acW\2\u060a\u00cb\3\2\2\2\u060b\u060c\7p\2\2\u060c"+ + "\u060d\7\u0083\2\2\u060d\u060e\5\36\20\2\u060e\u060f\7\u0084\2\2\u060f"+ + "\u00cd\3\2\2\2\u0610\u0611\7-\2\2\u0611\u0612\5\u00acW\2\u0612\u00cf\3"+ + "\2\2\2\u0613\u0616\5\u00aeX\2\u0614\u0616\5\36\20\2\u0615\u0613\3\2\2"+ + "\2\u0615\u0614\3\2\2\2\u0616\u00d1\3\2\2\2\u0617\u0618\7C\2\2\u0618\u0619"+ + "\5\u00d4k\2\u0619\u061b\5\u00d6l\2\u061a\u061c\7\u0088\2\2\u061b\u061a"+ + "\3\2\2\2\u061b\u061c\3\2\2\2\u061c\u00d3\3\2\2\2\u061d\u0622\5\u01b4\u00db"+ + "\2\u061e\u061f\7\u0085\2\2\u061f\u0621\5\u01b4\u00db\2\u0620\u061e\3\2"+ + "\2\2\u0621\u0624\3\2\2\2\u0622\u0620\3\2\2\2\u0622\u0623\3\2\2\2\u0623"+ + "\u00d5\3\2\2\2\u0624\u0622\3\2\2\2\u0625\u0627\7\177\2\2\u0626\u0628\5"+ + "\u00d8m\2\u0627\u0626\3\2\2\2\u0627\u0628\3\2\2\2\u0628\u062a\3\2\2\2"+ + "\u0629\u062b\5\u00dco\2\u062a\u0629\3\2\2\2\u062a\u062b\3\2\2\2\u062b"+ + "\u062d\3\2\2\2\u062c\u062e\5\u00e0q\2\u062d\u062c\3\2\2\2\u062d\u062e"+ + "\3\2\2\2\u062e\u062f\3\2\2\2\u062f\u0630\7\u0080\2\2\u0630\u00d7\3\2\2"+ + "\2\u0631\u0633\5\u00dan\2\u0632\u0631\3\2\2\2\u0633\u0634\3\2\2\2\u0634"+ + "\u0632\3\2\2\2\u0634\u0635\3\2\2\2\u0635\u00d9\3\2\2\2\u0636\u0637\7+"+ + "\2\2\u0637\u0638\7\r\2\2\u0638\u0639\5\u01b4\u00db\2\u0639\u063a\7\u0088"+ + "\2\2\u063a\u00db\3\2\2\2\u063b\u063d\5\u00dep\2\u063c\u063b\3\2\2\2\u063d"+ + "\u063e\3\2\2\2\u063e\u063c\3\2\2\2\u063e\u063f\3\2\2\2\u063f\u00dd\3\2"+ + "\2\2\u0640\u0641\7k\2\2\u0641\u0642\5\u01b4\u00db\2\u0642\u0643\7\u0093"+ + "\2\2\u0643\u0644\5\4\3\2\u0644\u0645\7\u0088\2\2\u0645\u0650\3\2\2\2\u0646"+ + "\u0647\7k\2\2\u0647\u0648\5\4\3\2\u0648\u0649\7\u0088\2\2\u0649\u0650"+ + "\3\2\2\2\u064a\u064b\7k\2\2\u064b\u064c\7\\\2\2\u064c\u064d\5\4\3\2\u064d"+ + "\u064e\7\u0088\2\2\u064e\u0650\3\2\2\2\u064f\u0640\3\2\2\2\u064f\u0646"+ + "\3\2\2\2\u064f\u064a\3\2\2\2\u0650\u00df\3\2\2\2\u0651\u0653\5\u00e2r"+ + "\2\u0652\u0651\3\2\2\2\u0653\u0654\3\2\2\2\u0654\u0652\3\2\2\2\u0654\u0655"+ + "\3\2\2\2\u0655\u00e1\3\2\2\2\u0656\u0659\5\u00d2j\2\u0657\u0659\5\u00e4"+ + "s\2\u0658\u0656\3\2\2\2\u0658\u0657\3\2\2\2\u0659\u00e3\3\2\2\2\u065a"+ + "\u065c\5\u0160\u00b1\2\u065b\u065a\3\2\2\2\u065b\u065c\3\2\2\2\u065c\u065e"+ + "\3\2\2\2\u065d\u065f\5\u0102\u0082\2\u065e\u065d\3\2\2\2\u065e\u065f\3"+ + "\2\2\2\u065f\u0665\3\2\2\2\u0660\u0666\5\u0190\u00c9\2\u0661\u0666\5\u0192"+ + "\u00ca\2\u0662\u0666\5\u0194\u00cb\2\u0663\u0666\5\u0196\u00cc\2\u0664"+ + "\u0666\5\u0198\u00cd\2\u0665\u0660\3\2\2\2\u0665\u0661\3\2\2\2\u0665\u0662"+ + "\3\2\2\2\u0665\u0663\3\2\2\2\u0665\u0664\3\2\2\2\u0666\u00e5\3\2\2\2\u0667"+ + "\u0668\5\u01b4\u00db\2\u0668\u0669\7\u0097\2\2\u0669\u066b\5\u01b4\u00db"+ + "\2\u066a\u066c\5\30\r\2\u066b\u066a\3\2\2\2\u066b\u066c\3\2\2\2\u066c"+ + "\u00e7\3\2\2\2\u066d\u066e\7\u0094\2\2\u066e\u0673\5\u00eav\2\u066f\u0670"+ + "\7\u0086\2\2\u0670\u0672\5\u00eav\2\u0671\u066f\3\2\2\2\u0672\u0675\3"+ + "\2\2\2\u0673\u0671\3\2\2\2\u0673\u0674\3\2\2\2\u0674\u0676\3\2\2\2\u0675"+ + "\u0673\3\2\2\2\u0676\u0677\7\u0095\2\2\u0677\u00e9\3\2\2\2\u0678\u067a"+ + "\5\u0160\u00b1\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067b\3"+ + "\2\2\2\u067b\u067c\5\u01b4\u00db\2\u067c\u00eb\3\2\2\2\u067d\u067e\7\u0087"+ + "\2\2\u067e\u0683\5\26\f\2\u067f\u0680\7\u0086\2\2\u0680\u0682\5\4\3\2"+ + "\u0681\u067f\3\2\2\2\u0682\u0685\3\2\2\2\u0683\u0681\3\2\2\2\u0683\u0684"+ + "\3\2\2\2\u0684\u00ed\3\2\2\2\u0685\u0683\3\2\2\2\u0686\u068b\5\4\3\2\u0687"+ + "\u0688\7\u0086\2\2\u0688\u068a\5\4\3\2\u0689\u0687\3\2\2\2\u068a\u068d"+ + "\3\2\2\2\u068b\u0689\3\2\2\2\u068b\u068c\3\2\2\2\u068c\u00ef\3\2\2\2\u068d"+ + "\u068b\3\2\2\2\u068e\u0690\5\u00f2z\2\u068f\u068e\3\2\2\2\u0690\u0691"+ + "\3\2\2\2\u0691\u068f\3\2\2\2\u0691\u0692\3\2\2\2\u0692\u00f1\3\2\2\2\u0693"+ + "\u0694\7q\2\2\u0694\u0695\5\u01b4\u00db\2\u0695\u0696\7\u0087\2\2\u0696"+ + "\u0697\5\u00f4{\2\u0697\u00f3\3\2\2\2\u0698\u06a3\5\u00fa~\2\u0699\u069c"+ + "\5\u00f6|\2\u069a\u069b\7\u0086\2\2\u069b\u069d\5\u00f8}\2\u069c\u069a"+ + "\3\2\2\2\u069c\u069d\3\2\2\2\u069d\u06a0\3\2\2\2\u069e\u069f\7\u0086\2"+ + "\2\u069f\u06a1\5\u00fa~\2\u06a0\u069e\3\2\2\2\u06a0\u06a1\3\2\2\2\u06a1"+ + "\u06a3\3\2\2\2\u06a2\u0698\3\2\2\2\u06a2\u0699\3\2\2\2\u06a3\u00f5\3\2"+ + "\2\2\u06a4\u06ac\5\26\f\2\u06a5\u06a7\7\34\2\2\u06a6\u06a8\7\u0096\2\2"+ + "\u06a7\u06a6\3\2\2\2\u06a7\u06a8\3\2\2\2\u06a8\u06ac\3\2\2\2\u06a9\u06ac"+ + "\7^\2\2\u06aa\u06ac\7h\2\2\u06ab\u06a4\3\2\2\2\u06ab\u06a5\3\2\2\2\u06ab"+ + "\u06a9\3\2\2\2\u06ab\u06aa\3\2\2\2\u06ac\u00f7\3\2\2\2\u06ad\u06b2\5\4"+ + "\3\2\u06ae\u06af\7\u0086\2\2\u06af\u06b1\5\4\3\2\u06b0\u06ae\3\2\2\2\u06b1"+ + "\u06b4\3\2\2\2\u06b2\u06b0\3\2\2\2\u06b2\u06b3\3\2\2\2\u06b3\u00f9\3\2"+ + "\2\2\u06b4\u06b2\3\2\2\2\u06b5\u06b6\7D\2\2\u06b6\u06b7\7\u0083\2\2\u06b7"+ + "\u06b8\7\u0084\2\2\u06b8\u00fb\3\2\2\2\u06b9\u06bb\7\177\2\2\u06ba\u06bc"+ + "\5\u00fe\u0080\2\u06bb\u06ba\3\2\2\2\u06bb\u06bc\3\2\2\2\u06bc\u06bd\3"+ + "\2\2\2\u06bd\u06be\7\u0080\2\2\u06be\u00fd\3\2\2\2\u06bf\u06c1\5\u0100"+ + "\u0081\2\u06c0\u06bf\3\2\2\2\u06c1\u06c2\3\2\2\2\u06c2\u06c0\3\2\2\2\u06c2"+ + "\u06c3\3\2\2\2\u06c3\u00ff\3\2\2\2\u06c4\u06c6\5\u0160\u00b1\2\u06c5\u06c4"+ + "\3\2\2\2\u06c5\u06c6\3\2\2\2\u06c6\u06c8\3\2\2\2\u06c7\u06c9\5\u0102\u0082"+ + "\2\u06c8\u06c7\3\2\2\2\u06c8\u06c9\3\2\2\2\u06c9\u06cc\3\2\2\2\u06ca\u06cd"+ + "\5\u0106\u0084\2\u06cb\u06cd\5\u01a4\u00d3\2\u06cc\u06ca\3\2\2\2\u06cc"+ + "\u06cb\3\2\2\2\u06cd\u0101\3\2\2\2\u06ce\u06d0\5\u0104\u0083\2\u06cf\u06ce"+ + "\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1\u06cf\3\2\2\2\u06d1\u06d2\3\2\2\2\u06d2"+ + "\u0103\3\2\2\2\u06d3\u06d4\t\f\2\2\u06d4\u0105\3\2\2\2\u06d5\u06e9\5\u01a0"+ + "\u00d1\2\u06d6\u06e9\5\u0108\u0085\2\u06d7\u06e9\5\u019a\u00ce\2\u06d8"+ + "\u06de\5\u0136\u009c\2\u06d9\u06df\5\u013a\u009e\2\u06da\u06db\5\u0178"+ + "\u00bd\2\u06db\u06dc\5L\'\2\u06dc\u06dd\7\u0088\2\2\u06dd\u06df\3\2\2"+ + "\2\u06de\u06d9\3\2\2\2\u06de\u06da\3\2\2\2\u06df\u06e9\3\2\2\2\u06e0\u06e9"+ + "\5\u01a6\u00d4\2\u06e1\u06e2\7n\2\2\u06e2\u06e9\5\u01a8\u00d5\2\u06e3"+ + "\u06e9\5\u0190\u00c9\2\u06e4\u06e9\5\u0192\u00ca\2\u06e5\u06e9\5\u0194"+ + "\u00cb\2\u06e6\u06e9\5\u0196\u00cc\2\u06e7\u06e9\5\u0198\u00cd\2\u06e8"+ + "\u06d5\3\2\2\2\u06e8\u06d6\3\2\2\2\u06e8\u06d7\3\2\2\2\u06e8\u06d8\3\2"+ + "\2\2\u06e8\u06e0\3\2\2\2\u06e8\u06e1\3\2\2\2\u06e8\u06e3\3\2\2\2\u06e8"+ + "\u06e4\3\2\2\2\u06e8\u06e5\3\2\2\2\u06e8\u06e6\3\2\2\2\u06e8\u06e7\3\2"+ + "\2\2\u06e9\u0107\3\2\2\2\u06ea\u06f0\7R\2\2\u06eb\u06ec\7Q\2\2\u06ec\u06f0"+ + "\7R\2\2\u06ed\u06ee\7R\2\2\u06ee\u06f0\7Q\2\2\u06ef\u06ea\3\2\2\2\u06ef"+ + "\u06eb\3\2\2\2\u06ef\u06ed\3\2\2\2\u06ef\u06f0\3\2\2\2\u06f0\u06f1\3\2"+ + "\2\2\u06f1\u06fb\5\6\4\2\u06f2\u06f3\5\4\3\2\u06f3\u06f4\7\u0085\2\2\u06f4"+ + "\u06f5\5\u01a2\u00d2\2\u06f5\u06fc\3\2\2\2\u06f6\u06fc\5\u01a8\u00d5\2"+ + "\u06f7\u06fc\5\u019e\u00d0\2\u06f8\u06fc\5\u01a2\u00d2\2\u06f9\u06fc\5"+ + "\u01ac\u00d7\2\u06fa\u06fc\5\u019c\u00cf\2\u06fb\u06f2\3\2\2\2\u06fb\u06f6"+ + "\3\2\2\2\u06fb\u06f7\3\2\2\2\u06fb\u06f8\3\2\2\2\u06fb\u06f9\3\2\2\2\u06fb"+ + "\u06fa\3\2\2\2\u06fc\u0109\3\2\2\2\u06fd\u0702\5\u010c\u0087\2\u06fe\u06ff"+ + "\7\u0086\2\2\u06ff\u0701\5\u010c\u0087\2\u0700\u06fe\3\2\2\2\u0701\u0704"+ + "\3\2\2\2\u0702\u0700\3\2\2\2\u0702\u0703\3\2\2\2\u0703\u010b\3\2\2\2\u0704"+ + "\u0702\3\2\2\2\u0705\u0706\5\u01b4\u00db\2\u0706\u0707\7\u0093\2\2\u0707"+ + "\u0708\5\36\20\2\u0708\u010d\3\2\2\2\u0709\u070e\5\u0110\u0089\2\u070a"+ + "\u070b\7\u0086\2\2\u070b\u070d\5\u0110\u0089\2\u070c\u070a\3\2\2\2\u070d"+ + "\u0710\3\2\2\2\u070e\u070c\3\2\2\2\u070e\u070f\3\2\2\2\u070f\u010f\3\2"+ + "\2\2\u0710\u070e\3\2\2\2\u0711\u0714\5\u01b4\u00db\2\u0712\u0713\7\u0093"+ + "\2\2\u0713\u0715\5\u0112\u008a\2\u0714\u0712\3\2\2\2\u0714\u0715\3\2\2"+ + "\2\u0715\u0111\3\2\2\2\u0716\u0719\5\36\20\2\u0717\u0719\5\u0146\u00a4"+ + "\2\u0718\u0716\3\2\2\2\u0718\u0717\3\2\2\2\u0719\u0113\3\2\2\2\u071a\u071d"+ + "\5\6\4\2\u071b\u071d\7n\2\2\u071c\u071a\3\2\2\2\u071c\u071b\3\2\2\2\u071d"+ + "\u0115\3\2\2\2\u071e\u071f\5\4\3\2\u071f\u0117\3\2\2\2\u0720\u0723\5\u00ac"+ + "W\2\u0721\u0723\7\u0088\2\2\u0722\u0720\3\2\2\2\u0722\u0721\3\2\2\2\u0723"+ + "\u0119\3\2\2\2\u0724\u072b\5\u0122\u0092\2\u0725\u0728\5\u011c\u008f\2"+ + "\u0726\u0727\7\u0086\2\2\u0727\u0729\5\u0122\u0092\2\u0728\u0726\3\2\2"+ + "\2\u0728\u0729\3\2\2\2\u0729\u072b\3\2\2\2\u072a\u0724\3\2\2\2\u072a\u0725"+ + "\3\2\2\2\u072b\u011b\3\2\2\2\u072c\u0731\5\u011e\u0090\2\u072d\u072e\7"+ + "\u0086\2\2\u072e\u0730\5\u011e\u0090\2\u072f\u072d\3\2\2\2\u0730\u0733"+ + "\3\2\2\2\u0731\u072f\3\2\2\2\u0731\u0732\3\2\2\2\u0732\u011d\3\2\2\2\u0733"+ + "\u0731\3\2\2\2\u0734\u0736\5\u0160\u00b1\2\u0735\u0734\3\2\2\2\u0735\u0736"+ + "\3\2\2\2\u0736\u0738\3\2\2\2\u0737\u0739\5\u0120\u0091\2\u0738\u0737\3"+ + "\2\2\2\u0738\u0739\3\2\2\2\u0739\u073a\3\2\2\2\u073a\u073d\5\u01ae\u00d8"+ + "\2\u073b\u073d\7\16\2\2\u073c\u0735\3\2\2\2\u073c\u073b\3\2\2\2\u073d"+ + "\u011f\3\2\2\2\u073e\u0747\7R\2\2\u073f\u0747\7J\2\2\u0740\u0747\78\2"+ + "\2\u0741\u0742\7R\2\2\u0742\u0747\7`\2\2\u0743\u0744\78\2\2\u0744\u0747"+ + "\7`\2\2\u0745\u0747\7`\2\2\u0746\u073e\3\2\2\2\u0746\u073f\3\2\2\2\u0746"+ + "\u0740\3\2\2\2\u0746\u0741\3\2\2\2\u0746\u0743\3\2\2\2\u0746\u0745\3\2"+ + "\2\2\u0747\u0121\3\2\2\2\u0748\u074a\5\u0160\u00b1\2\u0749\u0748\3\2\2"+ + "\2\u0749\u074a\3\2\2\2\u074a\u074b\3\2\2\2\u074b\u074c\7L\2\2\u074c\u074d"+ + "\5\u0142\u00a2\2\u074d\u074e\5\u01b4\u00db\2\u074e\u0123\3\2\2\2\u074f"+ + "\u0751\5\u0160\u00b1\2\u0750\u074f\3\2\2\2\u0750\u0751\3\2\2\2\u0751\u0753"+ + "\3\2\2\2\u0752\u0754\5\u012a\u0096\2\u0753\u0752\3\2\2\2\u0753\u0754\3"+ + "\2\2\2\u0754\u075f\3\2\2\2\u0755\u0756\7\63\2\2\u0756\u0758\5\u012c\u0097"+ + "\2\u0757\u0759\5\u0128\u0095\2\u0758\u0757\3\2\2\2\u0758\u0759\3\2\2\2"+ + "\u0759\u0760\3\2\2\2\u075a\u075b\7X\2\2\u075b\u075d\5\u012c\u0097\2\u075c"+ + "\u075e\5\u0126\u0094\2\u075d\u075c\3\2\2\2\u075d\u075e\3\2\2\2\u075e\u0760"+ + "\3\2\2\2\u075f\u0755\3\2\2\2\u075f\u075a\3\2\2\2\u0760\u0125\3\2\2\2\u0761"+ + "\u0763\5\u0160\u00b1\2\u0762\u0761\3\2\2\2\u0762\u0763\3\2\2\2\u0763\u0765"+ + "\3\2\2\2\u0764\u0766\5\u012a\u0096\2\u0765\u0764\3\2\2\2\u0765\u0766\3"+ + "\2\2\2\u0766\u0767\3\2\2\2\u0767\u0768\7\63\2\2\u0768\u0769\5\u012c\u0097"+ + "\2\u0769\u0127\3\2\2\2\u076a\u076c\5\u0160\u00b1\2\u076b\u076a\3\2\2\2"+ + "\u076b\u076c\3\2\2\2\u076c\u076e\3\2\2\2\u076d\u076f\5\u012a\u0096\2\u076e"+ + "\u076d\3\2\2\2\u076e\u076f\3\2\2\2\u076f\u0770\3\2\2\2\u0770\u0771\7X"+ + "\2\2\u0771\u0772\5\u012c\u0097\2\u0772\u0129\3\2\2\2\u0773\u077b\7O\2"+ + "\2\u0774\u077b\7;\2\2\u0775\u077b\7N\2\2\u0776\u0777\7O\2\2\u0777\u077b"+ + "\7;\2\2\u0778\u0779\7;\2\2\u0779\u077b\7O\2\2\u077a\u0773\3\2\2\2\u077a"+ + "\u0774\3\2\2\2\u077a\u0775\3\2\2\2\u077a\u0776\3\2\2\2\u077a\u0778\3\2"+ + "\2\2\u077b\u012b\3\2\2\2\u077c\u077f\5\u00acW\2\u077d\u077f\7\u0088\2"+ + "\2\u077e\u077c\3\2\2\2\u077e\u077d\3\2\2\2\u077f\u012d\3\2\2\2\u0780\u0782"+ + "\5\u0160\u00b1\2\u0781\u0780\3\2\2\2\u0781\u0782\3\2\2\2\u0782\u078b\3"+ + "\2\2\2\u0783\u0784\7\f\2\2\u0784\u0785\5\u00acW\2\u0785\u0786\5\u0132"+ + "\u009a\2\u0786\u078c\3\2\2\2\u0787\u0788\7S\2\2\u0788\u0789\5\u00acW\2"+ + "\u0789\u078a\5\u0130\u0099\2\u078a\u078c\3\2\2\2\u078b\u0783\3\2\2\2\u078b"+ + "\u0787\3\2\2\2\u078c\u012f\3\2\2\2\u078d\u078f\5\u0160\u00b1\2\u078e\u078d"+ + "\3\2\2\2\u078e\u078f\3\2\2\2\u078f\u0790\3\2\2\2\u0790\u0791\7\f\2\2\u0791"+ + "\u0792\5\u00acW\2\u0792\u0131\3\2\2\2\u0793\u0795\5\u0160\u00b1\2\u0794"+ + "\u0793\3\2\2\2\u0794\u0795\3\2\2\2\u0795\u0796\3\2\2\2\u0796\u0797\7S"+ + "\2\2\u0797\u0798\5\u00acW\2\u0798\u0133\3\2\2\2\u0799\u07b0\7\u0089\2"+ + "\2\u079a\u07b0\7\u008a\2\2\u079b\u07b0\7\u0091\2\2\u079c\u07b0\7\u0092"+ + "\2\2\u079d\u07b0\7\u0099\2\2\u079e\u07b0\7\u009a\2\2\u079f\u07b0\7b\2"+ + "\2\u07a0\u07b0\7,\2\2\u07a1\u07b0\7\u008b\2\2\u07a2\u07b0\7\u008c\2\2"+ + "\u07a3\u07b0\7\u008d\2\2\u07a4\u07b0\7\u008e\2\2\u07a5\u07b0\7\u008f\2"+ + "\2\u07a6\u07b0\7\u0090\2\2\u07a7\u07b0\7\u00aa\2\2\u07a8\u07b0\5\u017a"+ + "\u00be\2\u07a9\u07b0\7\u009e\2\2\u07aa\u07b0\7\u009f\2\2\u07ab\u07b0\7"+ + "\u0095\2\2\u07ac\u07b0\7\u0094\2\2\u07ad\u07b0\7\u00a1\2\2\u07ae\u07b0"+ + "\7\u00a0\2\2\u07af\u0799\3\2\2\2\u07af\u079a\3\2\2\2\u07af\u079b\3\2\2"+ + "\2\u07af\u079c\3\2\2\2\u07af\u079d\3\2\2\2\u07af\u079e\3\2\2\2\u07af\u079f"+ + "\3\2\2\2\u07af\u07a0\3\2\2\2\u07af\u07a1\3\2\2\2\u07af\u07a2\3\2\2\2\u07af"+ + "\u07a3\3\2\2\2\u07af\u07a4\3\2\2\2\u07af\u07a5\3\2\2\2\u07af\u07a6\3\2"+ + "\2\2\u07af\u07a7\3\2\2\2\u07af\u07a8\3\2\2\2\u07af\u07a9\3\2\2\2\u07af"+ + "\u07aa\3\2\2\2\u07af\u07ab\3\2\2\2\u07af\u07ac\3\2\2\2\u07af\u07ad\3\2"+ + "\2\2\u07af\u07ae\3\2\2\2\u07b0\u0135\3\2\2\2\u07b1\u07b2\t\r\2\2\u07b2"+ + "\u07b3\7H\2\2\u07b3\u07b4\5\6\4\2\u07b4\u07b5\7\u0083\2\2\u07b5\u07b6"+ + "\5\u01ae\u00d8\2\u07b6\u07b7\7\u0084\2\2\u07b7\u0137\3\2\2\2\u07b8\u07b9"+ + "\7\u0087\2\2\u07b9\u07ba\t\16\2\2\u07ba\u07bc\7\u0083\2\2\u07bb\u07bd"+ + "\5\32\16\2\u07bc\u07bb\3\2\2\2\u07bc\u07bd\3\2\2\2\u07bd\u07be\3\2\2\2"+ + "\u07be\u07bf\7\u0084\2\2\u07bf\u0139\3\2\2\2\u07c0\u07c3\5\u00acW\2\u07c1"+ + "\u07c3\7\u0088\2\2\u07c2\u07c0\3\2\2\2\u07c2\u07c1\3\2\2\2\u07c3\u013b"+ + "\3\2\2\2\u07c4\u07c5\7\u0087\2\2\u07c5\u07c6\5\u00eex\2\u07c6\u013d\3"+ + "\2\2\2\u07c7\u07cb\7\177\2\2\u07c8\u07ca\5\u0140\u00a1\2\u07c9\u07c8\3"+ + "\2\2\2\u07ca\u07cd\3\2\2\2\u07cb\u07c9\3\2\2\2\u07cb\u07cc\3\2\2\2\u07cc"+ + "\u07ce\3\2\2\2\u07cd\u07cb\3\2\2\2\u07ce\u07cf\7\u0080\2\2\u07cf\u013f"+ + "\3\2\2\2\u07d0\u07d2\5\u0160\u00b1\2\u07d1\u07d0\3\2\2\2\u07d1\u07d2\3"+ + "\2\2\2\u07d2\u07d4\3\2\2\2\u07d3\u07d5\5\u0102\u0082\2\u07d4\u07d3\3\2"+ + "\2\2\u07d4\u07d5\3\2\2\2\u07d5\u07e0\3\2\2\2\u07d6\u07e1\5\u0106\u0084"+ + "\2\u07d7\u07d8\7.\2\2\u07d8\u07da\5\6\4\2\u07d9\u07db\5\u0174\u00bb\2"+ + "\u07da\u07d9\3\2\2\2\u07db\u07dc\3\2\2\2\u07dc\u07da\3\2\2\2\u07dc\u07dd"+ + "\3\2\2\2\u07dd\u07de\3\2\2\2\u07de\u07df\7\u0088\2\2\u07df\u07e1\3\2\2"+ + "\2\u07e0\u07d6\3\2\2\2\u07e0\u07d7\3\2\2\2\u07e1\u0141\3\2\2\2\u07e2\u07ea"+ + "\5\b\5\2\u07e3\u07e5\t\17\2\2\u07e4\u07e3\3\2\2\2\u07e5\u07e8\3\2\2\2"+ + "\u07e6\u07e4\3\2\2\2\u07e6\u07e7\3\2\2\2\u07e7\u07e9\3\2\2\2\u07e8\u07e6"+ + "\3\2\2\2\u07e9\u07eb\5\u0144\u00a3\2\u07ea\u07e6\3\2\2\2\u07eb\u07ec\3"+ + "\2\2\2\u07ec\u07ea\3\2\2\2\u07ec\u07ed\3\2\2\2\u07ed\u0143\3\2\2\2\u07ee"+ + "\u07f2\7\u0081\2\2\u07ef\u07f1\7\u0086\2\2\u07f0\u07ef\3\2\2\2\u07f1\u07f4"+ + "\3\2\2\2\u07f2\u07f0\3\2\2\2\u07f2\u07f3\3\2\2\2\u07f3\u07f5\3\2\2\2\u07f4"+ + "\u07f2\3\2\2\2\u07f5\u07f6\7\u0082\2\2\u07f6\u0145\3\2\2\2\u07f7\u0803"+ + "\7\177\2\2\u07f8\u07fd\5\u0112\u008a\2\u07f9\u07fa\7\u0086\2\2\u07fa\u07fc"+ + "\5\u0112\u008a\2\u07fb\u07f9\3\2\2\2\u07fc\u07ff\3\2\2\2\u07fd\u07fb\3"+ + "\2\2\2\u07fd\u07fe\3\2\2\2\u07fe\u0801\3\2\2\2\u07ff\u07fd\3\2\2\2\u0800"+ + "\u0802\7\u0086\2\2\u0801\u0800\3\2\2\2\u0801\u0802\3\2\2\2\u0802\u0804"+ + "\3\2\2\2\u0803\u07f8\3\2\2\2\u0803\u0804\3\2\2\2\u0804\u0805\3\2\2\2\u0805"+ + "\u0806\7\u0080\2\2\u0806\u0147\3\2\2\2\u0807\u0808\7\u0094\2\2\u0808\u080d"+ + "\5\u014a\u00a6\2\u0809\u080a\7\u0086\2\2\u080a\u080c\5\u014a\u00a6\2\u080b"+ + "\u0809\3\2\2\2\u080c\u080f\3\2\2\2\u080d\u080b\3\2\2\2\u080d\u080e\3\2"+ + "\2\2\u080e\u0810\3\2\2\2\u080f\u080d\3\2\2\2\u0810\u0811\7\u0095\2\2\u0811"+ + "\u0149\3\2\2\2\u0812\u0814\5\u0160\u00b1\2\u0813\u0812\3\2\2\2\u0813\u0814"+ + "\3\2\2\2\u0814\u0816\3\2\2\2\u0815\u0817\5\u014c\u00a7\2\u0816\u0815\3"+ + "\2\2\2\u0816\u0817\3\2\2\2\u0817\u0818\3\2\2\2\u0818\u0819\5\u01b4\u00db"+ + "\2\u0819\u014b\3\2\2\2\u081a\u081b\t\20\2\2\u081b\u014d\3\2\2\2\u081c"+ + "\u081d\7\u0087\2\2\u081d\u081e\5\u00eex\2\u081e\u014f\3\2\2\2\u081f\u0823"+ + "\7\177\2\2\u0820\u0822\5\u0152\u00aa\2\u0821\u0820\3\2\2\2\u0822\u0825"+ + "\3\2\2\2\u0823\u0821\3\2\2\2\u0823\u0824\3\2\2\2\u0824\u0826\3\2\2\2\u0825"+ + "\u0823\3\2\2\2\u0826\u0827\7\u0080\2\2\u0827\u0151\3\2\2\2\u0828\u082a"+ + "\5\u0160\u00b1\2\u0829\u0828\3\2\2\2\u0829\u082a\3\2\2\2\u082a\u082c\3"+ + "\2\2\2\u082b\u082d\7D\2\2\u082c\u082b\3\2\2\2\u082c\u082d\3\2\2\2\u082d"+ + "\u086d\3\2\2\2\u082e\u0830\7i\2\2\u082f\u082e\3\2\2\2\u082f\u0830\3\2"+ + "\2\2\u0830\u0836\3\2\2\2\u0831\u0837\7R\2\2\u0832\u0833\7R\2\2\u0833\u0837"+ + "\7Q\2\2\u0834\u0835\7Q\2\2\u0835\u0837\7R\2\2\u0836\u0831\3\2\2\2\u0836"+ + "\u0832\3\2\2\2\u0836\u0834\3\2\2\2\u0836\u0837\3\2\2\2\u0837\u0838\3\2"+ + "\2\2\u0838\u0854\5\6\4\2\u0839\u083b\5\u01b4\u00db\2\u083a\u083c\5\u00e8"+ + "u\2\u083b\u083a\3\2\2\2\u083b\u083c\3\2\2\2\u083c\u083d\3\2\2\2\u083d"+ + "\u083f\7\u0083\2\2\u083e\u0840\5\u011a\u008e\2\u083f\u083e\3\2\2\2\u083f"+ + "\u0840\3\2\2\2\u0840\u0841\3\2\2\2\u0841\u0843\7\u0084\2\2\u0842\u0844"+ + "\5\u00f0y\2\u0843\u0842\3\2\2\2\u0843\u0844\3\2\2\2\u0844\u0845\3\2\2"+ + "\2\u0845\u0846\7\u0088\2\2\u0846\u0855\3\2\2\2\u0847\u0848\5\u01b4\u00db"+ + "\2\u0848\u0849\7\177\2\2\u0849\u084a\5\u0154\u00ab\2\u084a\u084b\7\u0080"+ + "\2\2\u084b\u0855\3\2\2\2\u084c\u084d\7`\2\2\u084d\u084e\7\u0081\2\2\u084e"+ + "\u084f\5\u011a\u008e\2\u084f\u0850\7\u0082\2\2\u0850\u0851\7\177\2\2\u0851"+ + "\u0852\5\u0154\u00ab\2\u0852\u0853\7\u0080\2\2\u0853\u0855\3\2\2\2\u0854"+ + "\u0839\3\2\2\2\u0854\u0847\3\2\2\2\u0854\u084c\3\2\2\2\u0855\u086e\3\2"+ + "\2\2\u0856\u0858\7i\2\2\u0857\u0856\3\2\2\2\u0857\u0858\3\2\2\2\u0858"+ + "\u0859\3\2\2\2\u0859\u085a\7n\2\2\u085a\u085c\5\u01b4\u00db\2\u085b\u085d"+ + "\5\u00e8u\2\u085c\u085b\3\2\2\2\u085c\u085d\3\2\2\2\u085d\u085e\3\2\2"+ + "\2\u085e\u0860\7\u0083\2\2\u085f\u0861\5\u011a\u008e\2\u0860\u085f\3\2"+ + "\2\2\u0860\u0861\3\2\2\2\u0861\u0862\3\2\2\2\u0862\u0864\7\u0084\2\2\u0863"+ + "\u0865\5\u00f0y\2\u0864\u0863\3\2\2\2\u0864\u0865\3\2\2\2\u0865\u0866"+ + "\3\2\2\2\u0866\u0867\7\u0088\2\2\u0867\u086e\3\2\2\2\u0868\u0869\7)\2"+ + "\2\u0869\u086a\5\6\4\2\u086a\u086b\5\u01b4\u00db\2\u086b\u086c\7\u0088"+ + "\2\2\u086c\u086e\3\2\2\2\u086d\u082f\3\2\2\2\u086d\u0857\3\2\2\2\u086d"+ + "\u0868\3\2\2\2\u086e\u0153\3\2\2\2\u086f\u0871\5\u0160\u00b1\2\u0870\u086f"+ + "\3\2\2\2\u0870\u0871\3\2\2\2\u0871\u0884\3\2\2\2\u0872\u0873\7\63\2\2"+ + "\u0873\u0879\7\u0088\2\2\u0874\u0876\5\u0160\u00b1\2\u0875\u0874\3\2\2"+ + "\2\u0875\u0876\3\2\2\2\u0876\u0877\3\2\2\2\u0877\u0878\7X\2\2\u0878\u087a"+ + "\7\u0088\2\2\u0879\u0875\3\2\2\2\u0879\u087a\3\2\2\2\u087a\u0885\3\2\2"+ + "\2\u087b\u087c\7X\2\2\u087c\u0882\7\u0088\2\2\u087d\u087f\5\u0160\u00b1"+ + "\2\u087e\u087d\3\2\2\2\u087e\u087f\3\2\2\2\u087f\u0880\3\2\2\2\u0880\u0881"+ + "\7\63\2\2\u0881\u0883\7\u0088\2\2\u0882\u087e\3\2\2\2\u0882\u0883\3\2"+ + "\2\2\u0883\u0885\3\2\2\2\u0884\u0872\3\2\2\2\u0884\u087b\3\2\2\2\u0885"+ + "\u0155\3\2\2\2\u0886\u0887\7\u0087\2\2\u0887\u0888\5\6\4\2\u0888\u0157"+ + "\3\2\2\2\u0889\u0895\7\177\2\2\u088a\u088f\5\u015a\u00ae\2\u088b\u088c"+ + "\7\u0086\2\2\u088c\u088e\5\u015a\u00ae\2\u088d\u088b\3\2\2\2\u088e\u0891"+ + "\3\2\2\2\u088f\u088d\3\2\2\2\u088f\u0890\3\2\2\2\u0890\u0893\3\2\2\2\u0891"+ + "\u088f\3\2\2\2\u0892\u0894\7\u0086\2\2\u0893\u0892\3\2\2\2\u0893\u0894"+ + "\3\2\2\2\u0894\u0896\3\2\2\2\u0895\u088a\3\2\2\2\u0895\u0896\3\2\2\2\u0896"+ + "\u0897\3\2\2\2\u0897\u0898\7\u0080\2\2\u0898\u0159\3\2\2\2\u0899\u089b"+ + "\5\u0160\u00b1\2\u089a\u0899\3\2\2\2\u089a\u089b\3\2\2\2\u089b\u089c\3"+ + "\2\2\2\u089c\u089f\5\u01b4\u00db\2\u089d\u089e\7\u0093\2\2\u089e\u08a0"+ + "\5\36\20\2\u089f\u089d\3\2\2\2\u089f\u08a0\3\2\2\2\u08a0\u015b\3\2\2\2"+ + "\u08a1\u08a2\7\u0081\2\2\u08a2\u08a3\5\u015e\u00b0\2\u08a3\u08a4\7\u0087"+ + "\2\2\u08a4\u08a6\5\u0166\u00b4\2\u08a5\u08a7\7\u0086\2\2\u08a6\u08a5\3"+ + "\2\2\2\u08a6\u08a7\3\2\2\2\u08a7\u08a8\3\2\2\2\u08a8\u08a9\7\u0082\2\2"+ + "\u08a9\u015d\3\2\2\2\u08aa\u08ad\5\u018e\u00c8\2\u08ab\u08ad\5\u01b4\u00db"+ + "\2\u08ac\u08aa\3\2\2\2\u08ac\u08ab\3\2\2\2\u08ad\u015f\3\2\2\2\u08ae\u08b0"+ + "\5\u0162\u00b2\2\u08af\u08ae\3\2\2\2\u08b0\u08b1\3\2\2\2\u08b1\u08af\3"+ + "\2\2\2\u08b1\u08b2\3\2\2\2\u08b2\u0161\3\2\2\2\u08b3\u08b7\7\u0081\2\2"+ + "\u08b4\u08b5\5\u0164\u00b3\2\u08b5\u08b6\7\u0087\2\2\u08b6\u08b8\3\2\2"+ + "\2\u08b7\u08b4\3\2\2\2\u08b7\u08b8\3\2\2\2\u08b8\u08b9\3\2\2\2\u08b9\u08bb"+ + "\5\u0166\u00b4\2\u08ba\u08bc\7\u0086\2\2\u08bb\u08ba\3\2\2\2\u08bb\u08bc"+ + "\3\2\2\2\u08bc\u08bd\3\2\2\2\u08bd\u08be\7\u0082\2\2\u08be\u0163\3\2\2"+ + "\2\u08bf\u08c2\5\u018e\u00c8\2\u08c0\u08c2\5\u01b4\u00db\2\u08c1\u08bf"+ + "\3\2\2\2\u08c1\u08c0\3\2\2\2\u08c2\u0165\3\2\2\2\u08c3\u08c8\5\u0168\u00b5"+ + "\2\u08c4\u08c5\7\u0086\2\2\u08c5\u08c7\5\u0168\u00b5\2\u08c6\u08c4\3\2"+ + "\2\2\u08c7\u08ca\3\2\2\2\u08c8\u08c6\3\2\2\2\u08c8\u08c9\3\2\2\2\u08c9"+ + "\u0167\3\2\2\2\u08ca\u08c8\3\2\2\2\u08cb\u08d8\5\4\3\2\u08cc\u08d5\7\u0083"+ + "\2\2\u08cd\u08d2\5\u016a\u00b6\2\u08ce\u08cf\7\u0086\2\2\u08cf\u08d1\5"+ + "\u016a\u00b6\2\u08d0\u08ce\3\2\2\2\u08d1\u08d4\3\2\2\2\u08d2\u08d0\3\2"+ + "\2\2\u08d2\u08d3\3\2\2\2\u08d3\u08d6\3\2\2\2\u08d4\u08d2\3\2\2\2\u08d5"+ + "\u08cd\3\2\2\2\u08d5\u08d6\3\2\2\2\u08d6\u08d7\3\2\2\2\u08d7\u08d9\7\u0084"+ + "\2\2\u08d8\u08cc\3\2\2\2\u08d8\u08d9\3\2\2\2\u08d9\u0169\3\2\2\2\u08da"+ + "\u08db\5\u01b4\u00db\2\u08db\u08dc\7\u0087\2\2\u08dc\u08de\3\2\2\2\u08dd"+ + "\u08da\3\2\2\2\u08dd\u08de\3\2\2\2\u08de\u08df\3\2\2\2\u08df\u08e0\5\36"+ + "\20\2\u08e0\u016b\3\2\2\2\u08e1\u08e4\5\16\b\2\u08e2\u08e4\5\26\f\2\u08e3"+ + "\u08e1\3\2\2\2\u08e3\u08e2\3\2\2\2\u08e4\u08e9\3\2\2\2\u08e5\u08e8\5\u0144"+ + "\u00a3\2\u08e6\u08e8\7\u0096\2\2\u08e7\u08e5\3\2\2\2\u08e7\u08e6\3\2\2"+ + "\2\u08e8\u08eb\3\2\2\2\u08e9\u08e7\3\2\2\2\u08e9\u08ea\3\2\2\2\u08ea\u08ec"+ + "\3\2\2\2\u08eb\u08e9\3\2\2\2\u08ec\u08ed\7\u008b\2\2\u08ed\u08f1\3\2\2"+ + "\2\u08ee\u08ef\7n\2\2\u08ef\u08f1\7\u008b\2\2\u08f0\u08e3\3\2\2\2\u08f0"+ + "\u08ee\3\2\2\2\u08f1\u016d\3\2\2\2\u08f2\u08f7\5\u0170\u00b9\2\u08f3\u08f4"+ + "\7\u0086\2\2\u08f4\u08f6\5\u0170\u00b9\2\u08f5\u08f3\3\2\2\2\u08f6\u08f9"+ + "\3\2\2\2\u08f7\u08f5\3\2\2\2\u08f7\u08f8\3\2\2\2\u08f8\u016f\3\2\2\2\u08f9"+ + "\u08f7\3\2\2\2\u08fa\u08fb\5\u01b4\u00db\2\u08fb\u08fc\7\u0093\2\2\u08fc"+ + "\u08fd\5\u0172\u00ba\2\u08fd\u0171\3\2\2\2\u08fe\u0900\7\u008e\2\2\u08ff"+ + "\u08fe\3\2\2\2\u08ff\u0900\3\2\2\2\u0900\u0901\3\2\2\2\u0901\u0904\5\36"+ + "\20\2\u0902\u0904\5\u0176\u00bc\2\u0903\u08ff\3\2\2\2\u0903\u0902\3\2"+ + "\2\2\u0904\u0173\3\2\2\2\u0905\u0906\5\u01b4\u00db\2\u0906\u0907\7\u0081"+ + "\2\2\u0907\u0908\5\36\20\2\u0908\u0909\7\u0082\2\2\u0909\u0175\3\2\2\2"+ + "\u090a\u090b\7[\2\2\u090b\u090c\5\6\4\2\u090c\u090d\7\u0081\2\2\u090d"+ + "\u090e\5\36\20\2\u090e\u090f\7\u0082\2\2\u090f\u0928\3\2\2\2\u0910\u0912"+ + "\7[\2\2\u0911\u0913\5\6\4\2\u0912\u0911\3\2\2\2\u0912\u0913\3\2\2\2\u0913"+ + "\u0914\3\2\2\2\u0914\u0916\7\u0081\2\2\u0915\u0917\5\36\20\2\u0916\u0915"+ + "\3\2\2\2\u0916\u0917\3\2\2\2\u0917\u0918\3\2\2\2\u0918\u0919\7\u0082\2"+ + "\2\u0919\u091a\7\177\2\2\u091a\u091f\5\36\20\2\u091b\u091c\7\u0086\2\2"+ + "\u091c\u091e\5\36\20\2\u091d\u091b\3\2\2\2\u091e\u0921\3\2\2\2\u091f\u091d"+ + "\3\2\2\2\u091f\u0920\3\2\2\2\u0920\u0923\3\2\2\2\u0921\u091f\3\2\2\2\u0922"+ + "\u0924\7\u0086\2\2\u0923\u0922\3\2\2\2\u0923\u0924\3\2\2\2\u0924\u0925"+ + "\3\2\2\2\u0925\u0926\7\u0080\2\2\u0926\u0928\3\2\2\2\u0927\u090a\3\2\2"+ + "\2\u0927\u0910\3\2\2\2\u0928\u0177\3\2\2\2\u0929\u092a\7\u0093\2\2\u092a"+ + "\u092b\7\u0095\2\2\u092b\u092c\6\u00bd\2\3\u092c\u0179\3\2\2\2\u092d\u092e"+ + "\7\u0095\2\2\u092e\u092f\7\u0095\2\2\u092f\u0930\6\u00be\3\3\u0930\u017b"+ + "\3\2\2\2\u0931\u0932\7\u0095\2\2\u0932\u0933\7\u00a1\2\2\u0933\u0934\6"+ + "\u00bf\4\3\u0934\u017d\3\2\2\2\u0935\u093e\5\u0180\u00c1\2\u0936\u093e"+ + "\5\u0182\u00c2\2\u0937\u093e\7v\2\2\u0938\u093e\7w\2\2\u0939\u093e\7x"+ + "\2\2\u093a\u093e\7y\2\2\u093b\u093e\7z\2\2\u093c\u093e\7E\2\2\u093d\u0935"+ + "\3\2\2\2\u093d\u0936\3\2\2\2\u093d\u0937\3\2\2\2\u093d\u0938\3\2\2\2\u093d"+ + "\u0939\3\2\2\2\u093d\u093a\3\2\2\2\u093d\u093b\3\2\2\2\u093d\u093c\3\2"+ + "\2\2\u093e\u017f\3\2\2\2\u093f\u0940\t\21\2\2\u0940\u0181\3\2\2\2\u0941"+ + "\u0946\5\u0184\u00c3\2\u0942\u0946\5\u0186\u00c4\2\u0943\u0946\7{\2\2"+ + "\u0944\u0946\7|\2\2\u0945\u0941\3\2\2\2\u0945\u0942\3\2\2\2\u0945\u0943"+ + "\3\2\2\2\u0945\u0944\3\2\2\2\u0946\u0183\3\2\2\2\u0947\u094b\7}\2\2\u0948"+ + "\u094a\5\u0188\u00c5\2\u0949\u0948\3\2\2\2\u094a\u094d\3\2\2\2\u094b\u0949"+ + "\3\2\2\2\u094b\u094c\3\2\2\2\u094c\u094e\3\2\2\2\u094d\u094b\3\2\2\2\u094e"+ + "\u094f\7\u00b2\2\2\u094f\u0185\3\2\2\2\u0950\u0954\7~\2\2\u0951\u0953"+ + "\5\u018a\u00c6\2\u0952\u0951\3\2\2\2\u0953\u0956\3\2\2\2\u0954\u0952\3"+ + "\2\2\2\u0954\u0955\3\2\2\2\u0955\u0957\3\2\2\2\u0956\u0954\3\2\2\2"; + private static final String _serializedATNSegment1 = + "\u0957\u0958\7\u00b2\2\2\u0958\u0187\3\2\2\2\u0959\u095e\5\u018c\u00c7"+ + "\2\u095a\u095e\7\u00ae\2\2\u095b\u095e\7\u00b0\2\2\u095c\u095e\7\u00b3"+ + "\2\2\u095d\u0959\3\2\2\2\u095d\u095a\3\2\2\2\u095d\u095b\3\2\2\2\u095d"+ + "\u095c\3\2\2\2\u095e\u0189\3\2\2\2\u095f\u0964\5\u018c\u00c7\2\u0960\u0964"+ + "\7\u00ae\2\2\u0961\u0964\7\u00b1\2\2\u0962\u0964\7\u00b4\2\2\u0963\u095f"+ + "\3\2\2\2\u0963\u0960\3\2\2\2\u0963\u0961\3\2\2\2\u0963\u0962\3\2\2\2\u0964"+ + "\u018b\3\2\2\2\u0965\u096a\5\36\20\2\u0966\u0967\7\u0086\2\2\u0967\u0969"+ + "\5\36\20\2\u0968\u0966\3\2\2\2\u0969\u096c\3\2\2\2\u096a\u0968\3\2\2\2"+ + "\u096a\u096b\3\2\2\2\u096b\u0973\3\2\2\2\u096c\u096a\3\2\2\2\u096d\u096f"+ + "\7\u0087\2\2\u096e\u0970\7\u00b6\2\2\u096f\u096e\3\2\2\2\u0970\u0971\3"+ + "\2\2\2\u0971\u096f\3\2\2\2\u0971\u0972\3\2\2\2\u0972\u0974\3\2\2\2\u0973"+ + "\u096d\3\2\2\2\u0973\u0974\3\2\2\2\u0974\u018d\3\2\2\2\u0975\u0976\t\22"+ + "\2\2\u0976\u018f\3\2\2\2\u0977\u0978\7\34\2\2\u0978\u097a\5\u01b4\u00db"+ + "\2\u0979\u097b\5\u00e8u\2\u097a\u0979\3\2\2\2\u097a\u097b\3\2\2\2\u097b"+ + "\u097d\3\2\2\2\u097c\u097e\5\u00ecw\2\u097d\u097c\3\2\2\2\u097d\u097e"+ + "\3\2\2\2\u097e\u0980\3\2\2\2\u097f\u0981\5\u00f0y\2\u0980\u097f\3\2\2"+ + "\2\u0980\u0981\3\2\2\2\u0981\u0982\3\2\2\2\u0982\u0984\5\u00fc\177\2\u0983"+ + "\u0985\7\u0088\2\2\u0984\u0983\3\2\2\2\u0984\u0985\3\2\2\2\u0985\u0191"+ + "\3\2\2\2\u0986\u0988\t\23\2\2\u0987\u0986\3\2\2\2\u0987\u0988\3\2\2\2"+ + "\u0988\u0989\3\2\2\2\u0989\u098a\7^\2\2\u098a\u098c\5\u01b4\u00db\2\u098b"+ + "\u098d\5\u00e8u\2\u098c\u098b\3\2\2\2\u098c\u098d\3\2\2\2\u098d\u098f"+ + "\3\2\2\2\u098e\u0990\5\u013c\u009f\2\u098f\u098e\3\2\2\2\u098f\u0990\3"+ + "\2\2\2\u0990\u0992\3\2\2\2\u0991\u0993\5\u00f0y\2\u0992\u0991\3\2\2\2"+ + "\u0992\u0993\3\2\2\2\u0993\u0994\3\2\2\2\u0994\u0996\5\u013e\u00a0\2\u0995"+ + "\u0997\7\u0088\2\2\u0996\u0995\3\2\2\2\u0996\u0997\3\2\2\2\u0997\u0193"+ + "\3\2\2\2\u0998\u0999\7:\2\2\u0999\u099b\5\u01b4\u00db\2\u099a\u099c\5"+ + "\u0148\u00a5\2\u099b\u099a\3\2\2\2\u099b\u099c\3\2\2\2\u099c\u099e\3\2"+ + "\2\2\u099d\u099f\5\u014e\u00a8\2\u099e\u099d\3\2\2\2\u099e\u099f\3\2\2"+ + "\2\u099f\u09a1\3\2\2\2\u09a0\u09a2\5\u00f0y\2\u09a1\u09a0\3\2\2\2\u09a1"+ + "\u09a2\3\2\2\2\u09a2\u09a3\3\2\2\2\u09a3\u09a5\5\u00fc\177\2\u09a4\u09a6"+ + "\7\u0088\2\2\u09a5\u09a4\3\2\2\2\u09a5\u09a6\3\2\2\2\u09a6\u0195\3\2\2"+ + "\2\u09a7\u09a8\7\'\2\2\u09a8\u09aa\5\u01b4\u00db\2\u09a9\u09ab\5\u0156"+ + "\u00ac\2\u09aa\u09a9\3\2\2\2\u09aa\u09ab\3\2\2\2\u09ab\u09ac\3\2\2\2\u09ac"+ + "\u09ae\5\u0158\u00ad\2\u09ad\u09af\7\u0088\2\2\u09ae\u09ad\3\2\2\2\u09ae"+ + "\u09af\3\2\2\2\u09af\u0197\3\2\2\2\u09b0\u09b1\7!\2\2\u09b1\u09b2\5\u0114"+ + "\u008b\2\u09b2\u09b4\5\u01b4\u00db\2\u09b3\u09b5\5\u0148\u00a5\2\u09b4"+ + "\u09b3\3\2\2\2\u09b4\u09b5\3\2\2\2\u09b5\u09b6\3\2\2\2\u09b6\u09b8\7\u0083"+ + "\2\2\u09b7\u09b9\5\u011a\u008e\2\u09b8\u09b7\3\2\2\2\u09b8\u09b9\3\2\2"+ + "\2\u09b9\u09ba\3\2\2\2\u09ba\u09bc\7\u0084\2\2\u09bb\u09bd\5\u00f0y\2"+ + "\u09bc\u09bb\3\2\2\2\u09bc\u09bd\3\2\2\2\u09bd\u09be\3\2\2\2\u09be\u09bf"+ + "\7\u0088\2\2\u09bf\u0199\3\2\2\2\u09c0\u09c1\7)\2\2\u09c1\u09ca\5\6\4"+ + "\2\u09c2\u09c3\5\u010e\u0088\2\u09c3\u09c4\7\u0088\2\2\u09c4\u09cb\3\2"+ + "\2\2\u09c5\u09c6\5\u0116\u008c\2\u09c6\u09c7\7\177\2\2\u09c7\u09c8\5\u012e"+ + "\u0098\2\u09c8\u09c9\7\u0080\2\2\u09c9\u09cb\3\2\2\2\u09ca\u09c2\3\2\2"+ + "\2\u09ca\u09c5\3\2\2\2\u09cb\u019b\3\2\2\2\u09cc\u09cd\5\u010e\u0088\2"+ + "\u09cd\u09ce\7\u0088\2\2\u09ce\u019d\3\2\2\2\u09cf\u09dd\5\u0116\u008c"+ + "\2\u09d0\u09d1\7\177\2\2\u09d1\u09d2\5\u0124\u0093\2\u09d2\u09d7\7\u0080"+ + "\2\2\u09d3\u09d4\7\u0093\2\2\u09d4\u09d5\5\u0112\u008a\2\u09d5\u09d6\7"+ + "\u0088\2\2\u09d6\u09d8\3\2\2\2\u09d7\u09d3\3\2\2\2\u09d7\u09d8\3\2\2\2"+ + "\u09d8\u09de\3\2\2\2\u09d9\u09da\5\u0178\u00bd\2\u09da\u09db\5L\'\2\u09db"+ + "\u09dc\7\u0088\2\2\u09dc\u09de\3\2\2\2\u09dd\u09d0\3\2\2\2\u09dd\u09d9"+ + "\3\2\2\2\u09de\u019f\3\2\2\2\u09df\u09e0\7\35\2\2\u09e0\u09e1\5\6\4\2"+ + "\u09e1\u09e2\5\u010a\u0086\2\u09e2\u09e3\7\u0088\2\2\u09e3\u01a1\3\2\2"+ + "\2\u09e4\u09e5\7`\2\2\u09e5\u09e6\7\u0081\2\2\u09e6\u09e7\5\u011a\u008e"+ + "\2\u09e7\u09f0\7\u0082\2\2\u09e8\u09e9\7\177\2\2\u09e9\u09ea\5\u0124\u0093"+ + "\2\u09ea\u09eb\7\u0080\2\2\u09eb\u09f1\3\2\2\2\u09ec\u09ed\5\u0178\u00bd"+ + "\2\u09ed\u09ee\5L\'\2\u09ee\u09ef\7\u0088\2\2\u09ef\u09f1\3\2\2\2\u09f0"+ + "\u09e8\3\2\2\2\u09f0\u09ec\3\2\2\2\u09f1\u01a3\3\2\2\2\u09f2\u09f3\7\u0092"+ + "\2\2\u09f3\u09f4\5\u01b4\u00db\2\u09f4\u09f5\7\u0083\2\2\u09f5\u09f6\7"+ + "\u0084\2\2\u09f6\u09f7\5\u013a\u009e\2\u09f7\u01a5\3\2\2\2\u09f8\u09f9"+ + "\5\u01b4\u00db\2\u09f9\u09fb\7\u0083\2\2\u09fa\u09fc\5\u011a\u008e\2\u09fb"+ + "\u09fa\3\2\2\2\u09fb\u09fc\3\2\2\2\u09fc\u09fd\3\2\2\2\u09fd\u09ff\7\u0084"+ + "\2\2\u09fe\u0a00\5\u0138\u009d\2\u09ff\u09fe\3\2\2\2\u09ff\u0a00\3\2\2"+ + "\2\u0a00\u0a01\3\2\2\2\u0a01\u0a02\5\u013a\u009e\2\u0a02\u01a7\3\2\2\2"+ + "\u0a03\u0a05\5\u01aa\u00d6\2\u0a04\u0a06\5\u00e8u\2\u0a05\u0a04\3\2\2"+ + "\2\u0a05\u0a06\3\2\2\2\u0a06\u0a07\3\2\2\2\u0a07\u0a09\7\u0083\2\2\u0a08"+ + "\u0a0a\5\u011a\u008e\2\u0a09\u0a08\3\2\2\2\u0a09\u0a0a\3\2\2\2\u0a0a\u0a0b"+ + "\3\2\2\2\u0a0b\u0a0d\7\u0084\2\2\u0a0c\u0a0e\5\u00f0y\2\u0a0d\u0a0c\3"+ + "\2\2\2\u0a0d\u0a0e\3\2\2\2\u0a0e\u0a14\3\2\2\2\u0a0f\u0a15\5\u0118\u008d"+ + "\2\u0a10\u0a11\5\u0178\u00bd\2\u0a11\u0a12\5L\'\2\u0a12\u0a13\7\u0088"+ + "\2\2\u0a13\u0a15\3\2\2\2\u0a14\u0a0f\3\2\2\2\u0a14\u0a10\3\2\2\2\u0a15"+ + "\u01a9\3\2\2\2\u0a16\u0a1c\5\u01b4\u00db\2\u0a17\u0a18\5\u01b4\u00db\2"+ + "\u0a18\u0a19\7\u0097\2\2\u0a19\u0a1a\5\u01b4\u00db\2\u0a1a\u0a1c\3\2\2"+ + "\2\u0a1b\u0a16\3\2\2\2\u0a1b\u0a17\3\2\2\2\u0a1c\u0a24\3\2\2\2\u0a1d\u0a1f"+ + "\5\30\r\2\u0a1e\u0a1d\3\2\2\2\u0a1e\u0a1f\3\2\2\2\u0a1f\u0a20\3\2\2\2"+ + "\u0a20\u0a21\7\u0085\2\2\u0a21\u0a23\5\u01b4\u00db\2\u0a22\u0a1e\3\2\2"+ + "\2\u0a23\u0a26\3\2\2\2\u0a24\u0a22\3\2\2\2\u0a24\u0a25\3\2\2\2\u0a25\u01ab"+ + "\3\2\2\2\u0a26\u0a24\3\2\2\2\u0a27\u0a28\7H\2\2\u0a28\u0a29\5\u0134\u009b"+ + "\2\u0a29\u0a2b\7\u0083\2\2\u0a2a\u0a2c\78\2\2\u0a2b\u0a2a\3\2\2\2\u0a2b"+ + "\u0a2c\3\2\2\2\u0a2c\u0a2d\3\2\2\2\u0a2d\u0a33\5\u01ae\u00d8\2\u0a2e\u0a30"+ + "\7\u0086\2\2\u0a2f\u0a31\78\2\2\u0a30\u0a2f\3\2\2\2\u0a30\u0a31\3\2\2"+ + "\2\u0a31\u0a32\3\2\2\2\u0a32\u0a34\5\u01ae\u00d8\2\u0a33\u0a2e\3\2\2\2"+ + "\u0a33\u0a34\3\2\2\2\u0a34\u0a35\3\2\2\2\u0a35\u0a3b\7\u0084\2\2\u0a36"+ + "\u0a3c\5\u013a\u009e\2\u0a37\u0a38\5\u0178\u00bd\2\u0a38\u0a39\5L\'\2"+ + "\u0a39\u0a3a\7\u0088\2\2\u0a3a\u0a3c\3\2\2\2\u0a3b\u0a36\3\2\2\2\u0a3b"+ + "\u0a37\3\2\2\2\u0a3c\u01ad\3\2\2\2\u0a3d\u0a3e\5\6\4\2\u0a3e\u0a41\5\u01b4"+ + "\u00db\2\u0a3f\u0a40\7\u0093\2\2\u0a40\u0a42\5\36\20\2\u0a41\u0a3f\3\2"+ + "\2\2\u0a41\u0a42\3\2\2\2\u0a42\u01af\3\2\2\2\u0a43\u0a45\7\u0083\2\2\u0a44"+ + "\u0a46\5\32\16\2\u0a45\u0a44\3\2\2\2\u0a45\u0a46\3\2\2\2\u0a46\u0a47\3"+ + "\2\2\2\u0a47\u0a48\7\u0084\2\2\u0a48\u01b1\3\2\2\2\u0a49\u0a4b\7\u0083"+ + "\2\2\u0a4a\u0a4c\5\32\16\2\u0a4b\u0a4a\3\2\2\2\u0a4b\u0a4c\3\2\2\2\u0a4c"+ + "\u0a4d\3\2\2\2\u0a4d\u0a4f\7\u0084\2\2\u0a4e\u0a50\5Z.\2\u0a4f\u0a4e\3"+ + "\2\2\2\u0a4f\u0a50\3\2\2\2\u0a50\u01b3\3\2\2\2\u0a51\u0a52\t\24\2\2\u0a52"+ + "\u01b5\3\2\2\2\u015a\u01b7\u01ba\u01bd\u01c2\u01c6\u01cc\u01cf\u01d4\u01d8"+ + "\u01df\u01e1\u01e9\u01f1\u01f7\u01fb\u0200\u020a\u0212\u021c\u0222\u0225"+ + "\u0229\u0231\u0236\u0240\u024d\u0255\u025b\u025d\u0264\u026c\u0274\u027c"+ + "\u0284\u028c\u0296\u0298\u029e\u02a3\u02ab\u02b3\u02bb\u02bd\u02c0\u02c7"+ + "\u02cc\u02d3\u02d7\u02d9\u02f5\u02f9\u02fe\u0302\u030a\u030d\u0312\u0316"+ + "\u031a\u0320\u032e\u0334\u0340\u0344\u0349\u034d\u0353\u035b\u0364\u0376"+ + "\u0379\u037e\u0381\u0390\u0396\u039a\u03a0\u03a5\u03a8\u03b0\u03b8\u03c3"+ + "\u03c8\u03cd\u03cf\u03d8\u03e0\u03e7\u03ef\u03f3\u03fc\u0401\u0403\u040c"+ + "\u0414\u0418\u041d\u041f\u0424\u0428\u042f\u0437\u0439\u043d\u0440\u0443"+ + "\u044b\u0455\u0466\u046d\u0471\u047b\u0480\u0487\u0490\u0495\u049c\u04a8"+ + "\u04b3\u04bb\u04c0\u04c9\u04d2\u04db\u04e1\u04e6\u04ea\u04ee\u04f2\u04f6"+ + "\u04fd\u0505\u0512\u051c\u0532\u0536\u053a\u053f\u0553\u0558\u055d\u0564"+ + "\u0567\u057d\u0589\u058d\u0595\u059d\u05a4\u05a8\u05ad\u05b0\u05b5\u05bd"+ + "\u05c2\u05c9\u05cf\u05d7\u05df\u05e2\u05e9\u05f0\u05f4\u05f7\u05fd\u0601"+ + "\u0607\u0615\u061b\u0622\u0627\u062a\u062d\u0634\u063e\u064f\u0654\u0658"+ + "\u065b\u065e\u0665\u066b\u0673\u0679\u0683\u068b\u0691\u069c\u06a0\u06a2"+ + "\u06a7\u06ab\u06b2\u06bb\u06c2\u06c5\u06c8\u06cc\u06d1\u06de\u06e8\u06ef"+ + "\u06fb\u0702\u070e\u0714\u0718\u071c\u0722\u0728\u072a\u0731\u0735\u0738"+ + "\u073c\u0746\u0749\u0750\u0753\u0758\u075d\u075f\u0762\u0765\u076b\u076e"+ + "\u077a\u077e\u0781\u078b\u078e\u0794\u07af\u07bc\u07c2\u07cb\u07d1\u07d4"+ + "\u07dc\u07e0\u07e6\u07ec\u07f2\u07fd\u0801\u0803\u080d\u0813\u0816\u0823"+ + "\u0829\u082c\u082f\u0836\u083b\u083f\u0843\u0854\u0857\u085c\u0860\u0864"+ + "\u086d\u0870\u0875\u0879\u087e\u0882\u0884\u088f\u0893\u0895\u089a\u089f"+ + "\u08a6\u08ac\u08b1\u08b7\u08bb\u08c1\u08c8\u08d2\u08d5\u08d8\u08dd\u08e3"+ + "\u08e7\u08e9\u08f0\u08f7\u08ff\u0903\u0912\u0916\u091f\u0923\u0927\u093d"+ + "\u0945\u094b\u0954\u095d\u0963\u096a\u0971\u0973\u097a\u097d\u0980\u0984"+ + "\u0987\u098c\u098f\u0992\u0996\u099b\u099e\u09a1\u09a5\u09aa\u09ae\u09b4"+ + "\u09b8\u09bc\u09ca\u09d7\u09dd\u09f0\u09fb\u09ff\u0a05\u0a09\u0a0d\u0a14"+ + "\u0a1b\u0a1e\u0a24\u0a2b\u0a30\u0a33\u0a3b\u0a41\u0a45\u0a4b\u0a4f"; + public static final String _serializedATN = Utils.join( + new String[] { + _serializedATNSegment0, + _serializedATNSegment1 + }, + "" + ); + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpParserBaseListener.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpParserBaseListener.java new file mode 100644 index 0000000000..7ac5d6f0c1 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpParserBaseListener.java @@ -0,0 +1,3103 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.antlr; + +// Generated from CSharpParser.g4 by ANTLR 4.9.2 + +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; + +/** + * This class provides an empty implementation of {@link CSharpParserListener}, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +public class CSharpParserBaseListener implements CSharpParserListener { + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCompilation_unit(CSharpParser.Compilation_unitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCompilation_unit(CSharpParser.Compilation_unitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNamespace_or_type_name(CSharpParser.Namespace_or_type_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNamespace_or_type_name(CSharpParser.Namespace_or_type_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_(CSharpParser.Type_Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_(CSharpParser.Type_Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBase_type(CSharpParser.Base_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBase_type(CSharpParser.Base_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTuple_type(CSharpParser.Tuple_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTuple_type(CSharpParser.Tuple_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTuple_element(CSharpParser.Tuple_elementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTuple_element(CSharpParser.Tuple_elementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimple_type(CSharpParser.Simple_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimple_type(CSharpParser.Simple_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNumeric_type(CSharpParser.Numeric_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNumeric_type(CSharpParser.Numeric_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIntegral_type(CSharpParser.Integral_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIntegral_type(CSharpParser.Integral_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFloating_point_type(CSharpParser.Floating_point_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFloating_point_type(CSharpParser.Floating_point_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClass_type(CSharpParser.Class_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClass_type(CSharpParser.Class_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_argument_list(CSharpParser.Type_argument_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_argument_list(CSharpParser.Type_argument_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArgument_list(CSharpParser.Argument_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArgument_list(CSharpParser.Argument_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArgument(CSharpParser.ArgumentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArgument(CSharpParser.ArgumentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpression(CSharpParser.ExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpression(CSharpParser.ExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNon_assignment_expression(CSharpParser.Non_assignment_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNon_assignment_expression(CSharpParser.Non_assignment_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAssignment(CSharpParser.AssignmentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAssignment(CSharpParser.AssignmentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAssignment_operator(CSharpParser.Assignment_operatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAssignment_operator(CSharpParser.Assignment_operatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConditional_expression(CSharpParser.Conditional_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConditional_expression(CSharpParser.Conditional_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNull_coalescing_expression(CSharpParser.Null_coalescing_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNull_coalescing_expression(CSharpParser.Null_coalescing_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConditional_or_expression(CSharpParser.Conditional_or_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConditional_or_expression(CSharpParser.Conditional_or_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConditional_and_expression(CSharpParser.Conditional_and_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConditional_and_expression(CSharpParser.Conditional_and_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInclusive_or_expression(CSharpParser.Inclusive_or_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInclusive_or_expression(CSharpParser.Inclusive_or_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExclusive_or_expression(CSharpParser.Exclusive_or_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExclusive_or_expression(CSharpParser.Exclusive_or_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnd_expression(CSharpParser.And_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnd_expression(CSharpParser.And_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEquality_expression(CSharpParser.Equality_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEquality_expression(CSharpParser.Equality_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRelational_expression(CSharpParser.Relational_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRelational_expression(CSharpParser.Relational_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShift_expression(CSharpParser.Shift_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShift_expression(CSharpParser.Shift_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAdditive_expression(CSharpParser.Additive_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAdditive_expression(CSharpParser.Additive_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMultiplicative_expression(CSharpParser.Multiplicative_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMultiplicative_expression(CSharpParser.Multiplicative_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSwitch_expression(CSharpParser.Switch_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSwitch_expression(CSharpParser.Switch_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSwitch_expression_arms(CSharpParser.Switch_expression_armsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSwitch_expression_arms(CSharpParser.Switch_expression_armsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSwitch_expression_arm(CSharpParser.Switch_expression_armContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSwitch_expression_arm(CSharpParser.Switch_expression_armContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRange_expression(CSharpParser.Range_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRange_expression(CSharpParser.Range_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnary_expression(CSharpParser.Unary_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnary_expression(CSharpParser.Unary_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrimary_expression(CSharpParser.Primary_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrimary_expression(CSharpParser.Primary_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLiteralExpression(CSharpParser.LiteralExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLiteralExpression(CSharpParser.LiteralExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpleNameExpression(CSharpParser.SimpleNameExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpleNameExpression(CSharpParser.SimpleNameExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParenthesisExpressions(CSharpParser.ParenthesisExpressionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParenthesisExpressions(CSharpParser.ParenthesisExpressionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMemberAccessExpression(CSharpParser.MemberAccessExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMemberAccessExpression(CSharpParser.MemberAccessExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLiteralAccessExpression(CSharpParser.LiteralAccessExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLiteralAccessExpression(CSharpParser.LiteralAccessExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterThisReferenceExpression(CSharpParser.ThisReferenceExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitThisReferenceExpression(CSharpParser.ThisReferenceExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBaseAccessExpression(CSharpParser.BaseAccessExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBaseAccessExpression(CSharpParser.BaseAccessExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterObjectCreationExpression(CSharpParser.ObjectCreationExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitObjectCreationExpression(CSharpParser.ObjectCreationExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTupleExpression(CSharpParser.TupleExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTupleExpression(CSharpParser.TupleExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeofExpression(CSharpParser.TypeofExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeofExpression(CSharpParser.TypeofExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCheckedExpression(CSharpParser.CheckedExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCheckedExpression(CSharpParser.CheckedExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUncheckedExpression(CSharpParser.UncheckedExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUncheckedExpression(CSharpParser.UncheckedExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefaultValueExpression(CSharpParser.DefaultValueExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefaultValueExpression(CSharpParser.DefaultValueExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnonymousMethodExpression(CSharpParser.AnonymousMethodExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnonymousMethodExpression(CSharpParser.AnonymousMethodExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSizeofExpression(CSharpParser.SizeofExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSizeofExpression(CSharpParser.SizeofExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNameofExpression(CSharpParser.NameofExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNameofExpression(CSharpParser.NameofExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterThrowable_expression(CSharpParser.Throwable_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitThrowable_expression(CSharpParser.Throwable_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterThrow_expression(CSharpParser.Throw_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitThrow_expression(CSharpParser.Throw_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMember_access(CSharpParser.Member_accessContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMember_access(CSharpParser.Member_accessContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBracket_expression(CSharpParser.Bracket_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBracket_expression(CSharpParser.Bracket_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexer_argument(CSharpParser.Indexer_argumentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexer_argument(CSharpParser.Indexer_argumentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPredefined_type(CSharpParser.Predefined_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPredefined_type(CSharpParser.Predefined_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpression_list(CSharpParser.Expression_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpression_list(CSharpParser.Expression_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterObject_or_collection_initializer(CSharpParser.Object_or_collection_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitObject_or_collection_initializer(CSharpParser.Object_or_collection_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterObject_initializer(CSharpParser.Object_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitObject_initializer(CSharpParser.Object_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMember_initializer_list(CSharpParser.Member_initializer_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMember_initializer_list(CSharpParser.Member_initializer_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMember_initializer(CSharpParser.Member_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMember_initializer(CSharpParser.Member_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInitializer_value(CSharpParser.Initializer_valueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInitializer_value(CSharpParser.Initializer_valueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCollection_initializer(CSharpParser.Collection_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCollection_initializer(CSharpParser.Collection_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterElement_initializer(CSharpParser.Element_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitElement_initializer(CSharpParser.Element_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnonymous_object_initializer(CSharpParser.Anonymous_object_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnonymous_object_initializer(CSharpParser.Anonymous_object_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMember_declarator_list(CSharpParser.Member_declarator_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMember_declarator_list(CSharpParser.Member_declarator_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMember_declarator(CSharpParser.Member_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMember_declarator(CSharpParser.Member_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnbound_type_name(CSharpParser.Unbound_type_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnbound_type_name(CSharpParser.Unbound_type_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGeneric_dimension_specifier(CSharpParser.Generic_dimension_specifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGeneric_dimension_specifier(CSharpParser.Generic_dimension_specifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIsType(CSharpParser.IsTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIsType(CSharpParser.IsTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIsTypePatternArms(CSharpParser.IsTypePatternArmsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIsTypePatternArms(CSharpParser.IsTypePatternArmsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIsTypePatternArm(CSharpParser.IsTypePatternArmContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIsTypePatternArm(CSharpParser.IsTypePatternArmContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLambda_expression(CSharpParser.Lambda_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLambda_expression(CSharpParser.Lambda_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnonymous_function_signature(CSharpParser.Anonymous_function_signatureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnonymous_function_signature(CSharpParser.Anonymous_function_signatureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplicit_anonymous_function_parameter_list(CSharpParser.Explicit_anonymous_function_parameter_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplicit_anonymous_function_parameter_list(CSharpParser.Explicit_anonymous_function_parameter_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplicit_anonymous_function_parameter(CSharpParser.Explicit_anonymous_function_parameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplicit_anonymous_function_parameter(CSharpParser.Explicit_anonymous_function_parameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterImplicit_anonymous_function_parameter_list(CSharpParser.Implicit_anonymous_function_parameter_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitImplicit_anonymous_function_parameter_list(CSharpParser.Implicit_anonymous_function_parameter_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnonymous_function_body(CSharpParser.Anonymous_function_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnonymous_function_body(CSharpParser.Anonymous_function_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQuery_expression(CSharpParser.Query_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQuery_expression(CSharpParser.Query_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrom_clause(CSharpParser.From_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrom_clause(CSharpParser.From_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQuery_body(CSharpParser.Query_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQuery_body(CSharpParser.Query_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQuery_body_clause(CSharpParser.Query_body_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQuery_body_clause(CSharpParser.Query_body_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLet_clause(CSharpParser.Let_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLet_clause(CSharpParser.Let_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWhere_clause(CSharpParser.Where_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWhere_clause(CSharpParser.Where_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCombined_join_clause(CSharpParser.Combined_join_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCombined_join_clause(CSharpParser.Combined_join_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOrderby_clause(CSharpParser.Orderby_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOrderby_clause(CSharpParser.Orderby_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOrdering(CSharpParser.OrderingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOrdering(CSharpParser.OrderingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelect_or_group_clause(CSharpParser.Select_or_group_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelect_or_group_clause(CSharpParser.Select_or_group_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQuery_continuation(CSharpParser.Query_continuationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQuery_continuation(CSharpParser.Query_continuationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStatement(CSharpParser.StatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStatement(CSharpParser.StatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDeclarationStatement(CSharpParser.DeclarationStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDeclarationStatement(CSharpParser.DeclarationStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLocal_function_declaration(CSharpParser.Local_function_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLocal_function_declaration(CSharpParser.Local_function_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLocal_function_header(CSharpParser.Local_function_headerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLocal_function_header(CSharpParser.Local_function_headerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLocal_function_modifiers(CSharpParser.Local_function_modifiersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLocal_function_modifiers(CSharpParser.Local_function_modifiersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLocal_function_body(CSharpParser.Local_function_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLocal_function_body(CSharpParser.Local_function_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLabeled_Statement(CSharpParser.Labeled_StatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLabeled_Statement(CSharpParser.Labeled_StatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEmbedded_statement(CSharpParser.Embedded_statementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEmbedded_statement(CSharpParser.Embedded_statementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTheEmptyStatement(CSharpParser.TheEmptyStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTheEmptyStatement(CSharpParser.TheEmptyStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpressionStatement(CSharpParser.ExpressionStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpressionStatement(CSharpParser.ExpressionStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIfStatement(CSharpParser.IfStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIfStatement(CSharpParser.IfStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSwitchStatement(CSharpParser.SwitchStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSwitchStatement(CSharpParser.SwitchStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWhileStatement(CSharpParser.WhileStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWhileStatement(CSharpParser.WhileStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDoStatement(CSharpParser.DoStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDoStatement(CSharpParser.DoStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterForStatement(CSharpParser.ForStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitForStatement(CSharpParser.ForStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterForeachStatement(CSharpParser.ForeachStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitForeachStatement(CSharpParser.ForeachStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBreakStatement(CSharpParser.BreakStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBreakStatement(CSharpParser.BreakStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterContinueStatement(CSharpParser.ContinueStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitContinueStatement(CSharpParser.ContinueStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGotoStatement(CSharpParser.GotoStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGotoStatement(CSharpParser.GotoStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReturnStatement(CSharpParser.ReturnStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReturnStatement(CSharpParser.ReturnStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterThrowStatement(CSharpParser.ThrowStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitThrowStatement(CSharpParser.ThrowStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTryStatement(CSharpParser.TryStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTryStatement(CSharpParser.TryStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCheckedStatement(CSharpParser.CheckedStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCheckedStatement(CSharpParser.CheckedStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUncheckedStatement(CSharpParser.UncheckedStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUncheckedStatement(CSharpParser.UncheckedStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLockStatement(CSharpParser.LockStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLockStatement(CSharpParser.LockStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUsingStatement(CSharpParser.UsingStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUsingStatement(CSharpParser.UsingStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterYieldStatement(CSharpParser.YieldStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitYieldStatement(CSharpParser.YieldStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnsafeStatement(CSharpParser.UnsafeStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnsafeStatement(CSharpParser.UnsafeStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFixedStatement(CSharpParser.FixedStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFixedStatement(CSharpParser.FixedStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBlock(CSharpParser.BlockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBlock(CSharpParser.BlockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLocal_variable_declaration(CSharpParser.Local_variable_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLocal_variable_declaration(CSharpParser.Local_variable_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLocal_variable_type(CSharpParser.Local_variable_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLocal_variable_type(CSharpParser.Local_variable_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLocal_variable_declarator(CSharpParser.Local_variable_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLocal_variable_declarator(CSharpParser.Local_variable_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLocal_variable_initializer(CSharpParser.Local_variable_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLocal_variable_initializer(CSharpParser.Local_variable_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLocal_constant_declaration(CSharpParser.Local_constant_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLocal_constant_declaration(CSharpParser.Local_constant_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIf_body(CSharpParser.If_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIf_body(CSharpParser.If_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSwitch_section(CSharpParser.Switch_sectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSwitch_section(CSharpParser.Switch_sectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSwitch_label(CSharpParser.Switch_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSwitch_label(CSharpParser.Switch_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCase_guard(CSharpParser.Case_guardContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCase_guard(CSharpParser.Case_guardContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStatement_list(CSharpParser.Statement_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStatement_list(CSharpParser.Statement_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFor_initializer(CSharpParser.For_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFor_initializer(CSharpParser.For_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFor_iterator(CSharpParser.For_iteratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFor_iterator(CSharpParser.For_iteratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCatch_clauses(CSharpParser.Catch_clausesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCatch_clauses(CSharpParser.Catch_clausesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSpecific_catch_clause(CSharpParser.Specific_catch_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSpecific_catch_clause(CSharpParser.Specific_catch_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGeneral_catch_clause(CSharpParser.General_catch_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGeneral_catch_clause(CSharpParser.General_catch_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterException_filter(CSharpParser.Exception_filterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitException_filter(CSharpParser.Exception_filterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFinally_clause(CSharpParser.Finally_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFinally_clause(CSharpParser.Finally_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterResource_acquisition(CSharpParser.Resource_acquisitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitResource_acquisition(CSharpParser.Resource_acquisitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNamespace_declaration(CSharpParser.Namespace_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNamespace_declaration(CSharpParser.Namespace_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQualified_identifier(CSharpParser.Qualified_identifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQualified_identifier(CSharpParser.Qualified_identifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNamespace_body(CSharpParser.Namespace_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNamespace_body(CSharpParser.Namespace_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExtern_alias_directives(CSharpParser.Extern_alias_directivesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExtern_alias_directives(CSharpParser.Extern_alias_directivesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExtern_alias_directive(CSharpParser.Extern_alias_directiveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExtern_alias_directive(CSharpParser.Extern_alias_directiveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUsing_directives(CSharpParser.Using_directivesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUsing_directives(CSharpParser.Using_directivesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUsingAliasDirective(CSharpParser.UsingAliasDirectiveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUsingAliasDirective(CSharpParser.UsingAliasDirectiveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUsingNamespaceDirective(CSharpParser.UsingNamespaceDirectiveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUsingNamespaceDirective(CSharpParser.UsingNamespaceDirectiveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUsingStaticDirective(CSharpParser.UsingStaticDirectiveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUsingStaticDirective(CSharpParser.UsingStaticDirectiveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNamespace_member_declarations(CSharpParser.Namespace_member_declarationsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNamespace_member_declarations(CSharpParser.Namespace_member_declarationsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNamespace_member_declaration(CSharpParser.Namespace_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNamespace_member_declaration(CSharpParser.Namespace_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_declaration(CSharpParser.Type_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_declaration(CSharpParser.Type_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQualified_alias_member(CSharpParser.Qualified_alias_memberContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQualified_alias_member(CSharpParser.Qualified_alias_memberContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_parameter_list(CSharpParser.Type_parameter_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_parameter_list(CSharpParser.Type_parameter_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_parameter(CSharpParser.Type_parameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_parameter(CSharpParser.Type_parameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClass_base(CSharpParser.Class_baseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClass_base(CSharpParser.Class_baseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterface_type_list(CSharpParser.Interface_type_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterface_type_list(CSharpParser.Interface_type_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_parameter_constraints_clauses(CSharpParser.Type_parameter_constraints_clausesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_parameter_constraints_clauses(CSharpParser.Type_parameter_constraints_clausesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_parameter_constraints_clause(CSharpParser.Type_parameter_constraints_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_parameter_constraints_clause(CSharpParser.Type_parameter_constraints_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_parameter_constraints(CSharpParser.Type_parameter_constraintsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_parameter_constraints(CSharpParser.Type_parameter_constraintsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrimary_constraint(CSharpParser.Primary_constraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrimary_constraint(CSharpParser.Primary_constraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSecondary_constraints(CSharpParser.Secondary_constraintsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSecondary_constraints(CSharpParser.Secondary_constraintsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstructor_constraint(CSharpParser.Constructor_constraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstructor_constraint(CSharpParser.Constructor_constraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClass_body(CSharpParser.Class_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClass_body(CSharpParser.Class_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClass_member_declarations(CSharpParser.Class_member_declarationsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClass_member_declarations(CSharpParser.Class_member_declarationsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClass_member_declaration(CSharpParser.Class_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClass_member_declaration(CSharpParser.Class_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAll_member_modifiers(CSharpParser.All_member_modifiersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAll_member_modifiers(CSharpParser.All_member_modifiersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAll_member_modifier(CSharpParser.All_member_modifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAll_member_modifier(CSharpParser.All_member_modifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCommon_member_declaration(CSharpParser.Common_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCommon_member_declaration(CSharpParser.Common_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTyped_member_declaration(CSharpParser.Typed_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTyped_member_declaration(CSharpParser.Typed_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstant_declarators(CSharpParser.Constant_declaratorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstant_declarators(CSharpParser.Constant_declaratorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstant_declarator(CSharpParser.Constant_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstant_declarator(CSharpParser.Constant_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariable_declarators(CSharpParser.Variable_declaratorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariable_declarators(CSharpParser.Variable_declaratorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariable_declarator(CSharpParser.Variable_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariable_declarator(CSharpParser.Variable_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariable_initializer(CSharpParser.Variable_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariable_initializer(CSharpParser.Variable_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReturn_type(CSharpParser.Return_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReturn_type(CSharpParser.Return_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMember_name(CSharpParser.Member_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMember_name(CSharpParser.Member_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMethod_body(CSharpParser.Method_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMethod_body(CSharpParser.Method_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFormal_parameter_list(CSharpParser.Formal_parameter_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFormal_parameter_list(CSharpParser.Formal_parameter_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFixed_parameters(CSharpParser.Fixed_parametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFixed_parameters(CSharpParser.Fixed_parametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFixed_parameter(CSharpParser.Fixed_parameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFixed_parameter(CSharpParser.Fixed_parameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParameter_modifier(CSharpParser.Parameter_modifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParameter_modifier(CSharpParser.Parameter_modifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParameter_array(CSharpParser.Parameter_arrayContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParameter_array(CSharpParser.Parameter_arrayContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAccessor_declarations(CSharpParser.Accessor_declarationsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAccessor_declarations(CSharpParser.Accessor_declarationsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGet_accessor_declaration(CSharpParser.Get_accessor_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGet_accessor_declaration(CSharpParser.Get_accessor_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSet_accessor_declaration(CSharpParser.Set_accessor_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSet_accessor_declaration(CSharpParser.Set_accessor_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAccessor_modifier(CSharpParser.Accessor_modifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAccessor_modifier(CSharpParser.Accessor_modifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAccessor_body(CSharpParser.Accessor_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAccessor_body(CSharpParser.Accessor_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEvent_accessor_declarations(CSharpParser.Event_accessor_declarationsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEvent_accessor_declarations(CSharpParser.Event_accessor_declarationsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAdd_accessor_declaration(CSharpParser.Add_accessor_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAdd_accessor_declaration(CSharpParser.Add_accessor_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRemove_accessor_declaration(CSharpParser.Remove_accessor_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRemove_accessor_declaration(CSharpParser.Remove_accessor_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOverloadable_operator(CSharpParser.Overloadable_operatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOverloadable_operator(CSharpParser.Overloadable_operatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConversion_operator_declarator(CSharpParser.Conversion_operator_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConversion_operator_declarator(CSharpParser.Conversion_operator_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstructor_initializer(CSharpParser.Constructor_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstructor_initializer(CSharpParser.Constructor_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBody(CSharpParser.BodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBody(CSharpParser.BodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStruct_interfaces(CSharpParser.Struct_interfacesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStruct_interfaces(CSharpParser.Struct_interfacesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStruct_body(CSharpParser.Struct_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStruct_body(CSharpParser.Struct_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStruct_member_declaration(CSharpParser.Struct_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStruct_member_declaration(CSharpParser.Struct_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArray_type(CSharpParser.Array_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArray_type(CSharpParser.Array_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRank_specifier(CSharpParser.Rank_specifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRank_specifier(CSharpParser.Rank_specifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArray_initializer(CSharpParser.Array_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArray_initializer(CSharpParser.Array_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariant_type_parameter_list(CSharpParser.Variant_type_parameter_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariant_type_parameter_list(CSharpParser.Variant_type_parameter_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariant_type_parameter(CSharpParser.Variant_type_parameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariant_type_parameter(CSharpParser.Variant_type_parameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariance_annotation(CSharpParser.Variance_annotationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariance_annotation(CSharpParser.Variance_annotationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterface_base(CSharpParser.Interface_baseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterface_base(CSharpParser.Interface_baseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterface_body(CSharpParser.Interface_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterface_body(CSharpParser.Interface_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterface_member_declaration(CSharpParser.Interface_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterface_member_declaration(CSharpParser.Interface_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterface_accessors(CSharpParser.Interface_accessorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterface_accessors(CSharpParser.Interface_accessorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnum_base(CSharpParser.Enum_baseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnum_base(CSharpParser.Enum_baseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnum_body(CSharpParser.Enum_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnum_body(CSharpParser.Enum_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnum_member_declaration(CSharpParser.Enum_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnum_member_declaration(CSharpParser.Enum_member_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGlobal_attribute_section(CSharpParser.Global_attribute_sectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGlobal_attribute_section(CSharpParser.Global_attribute_sectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGlobal_attribute_target(CSharpParser.Global_attribute_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGlobal_attribute_target(CSharpParser.Global_attribute_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAttributes(CSharpParser.AttributesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAttributes(CSharpParser.AttributesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAttribute_section(CSharpParser.Attribute_sectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAttribute_section(CSharpParser.Attribute_sectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAttribute_target(CSharpParser.Attribute_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAttribute_target(CSharpParser.Attribute_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAttribute_list(CSharpParser.Attribute_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAttribute_list(CSharpParser.Attribute_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAttribute(CSharpParser.AttributeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAttribute(CSharpParser.AttributeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAttribute_argument(CSharpParser.Attribute_argumentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAttribute_argument(CSharpParser.Attribute_argumentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPointer_type(CSharpParser.Pointer_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPointer_type(CSharpParser.Pointer_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFixed_pointer_declarators(CSharpParser.Fixed_pointer_declaratorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFixed_pointer_declarators(CSharpParser.Fixed_pointer_declaratorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFixed_pointer_declarator(CSharpParser.Fixed_pointer_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFixed_pointer_declarator(CSharpParser.Fixed_pointer_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFixed_pointer_initializer(CSharpParser.Fixed_pointer_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFixed_pointer_initializer(CSharpParser.Fixed_pointer_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFixed_size_buffer_declarator(CSharpParser.Fixed_size_buffer_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFixed_size_buffer_declarator(CSharpParser.Fixed_size_buffer_declaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStackalloc_initializer(CSharpParser.Stackalloc_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStackalloc_initializer(CSharpParser.Stackalloc_initializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRight_arrow(CSharpParser.Right_arrowContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRight_arrow(CSharpParser.Right_arrowContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRight_shift(CSharpParser.Right_shiftContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRight_shift(CSharpParser.Right_shiftContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRight_shift_assignment(CSharpParser.Right_shift_assignmentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRight_shift_assignment(CSharpParser.Right_shift_assignmentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLiteral(CSharpParser.LiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLiteral(CSharpParser.LiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBoolean_literal(CSharpParser.Boolean_literalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBoolean_literal(CSharpParser.Boolean_literalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterString_literal(CSharpParser.String_literalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitString_literal(CSharpParser.String_literalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterpolated_regular_string(CSharpParser.Interpolated_regular_stringContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterpolated_regular_string(CSharpParser.Interpolated_regular_stringContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterpolated_verbatium_string(CSharpParser.Interpolated_verbatium_stringContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterpolated_verbatium_string(CSharpParser.Interpolated_verbatium_stringContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterpolated_regular_string_part(CSharpParser.Interpolated_regular_string_partContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterpolated_regular_string_part(CSharpParser.Interpolated_regular_string_partContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterpolated_verbatium_string_part(CSharpParser.Interpolated_verbatium_string_partContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterpolated_verbatium_string_part(CSharpParser.Interpolated_verbatium_string_partContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterpolated_string_expression(CSharpParser.Interpolated_string_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterpolated_string_expression(CSharpParser.Interpolated_string_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterKeyword(CSharpParser.KeywordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitKeyword(CSharpParser.KeywordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClass_definition(CSharpParser.Class_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClass_definition(CSharpParser.Class_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStruct_definition(CSharpParser.Struct_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStruct_definition(CSharpParser.Struct_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterface_definition(CSharpParser.Interface_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterface_definition(CSharpParser.Interface_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnum_definition(CSharpParser.Enum_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnum_definition(CSharpParser.Enum_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDelegate_definition(CSharpParser.Delegate_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDelegate_definition(CSharpParser.Delegate_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEvent_declaration(CSharpParser.Event_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEvent_declaration(CSharpParser.Event_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterField_declaration(CSharpParser.Field_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitField_declaration(CSharpParser.Field_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterProperty_declaration(CSharpParser.Property_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitProperty_declaration(CSharpParser.Property_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstant_declaration(CSharpParser.Constant_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstant_declaration(CSharpParser.Constant_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexer_declaration(CSharpParser.Indexer_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexer_declaration(CSharpParser.Indexer_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDestructor_definition(CSharpParser.Destructor_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDestructor_definition(CSharpParser.Destructor_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstructor_declaration(CSharpParser.Constructor_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstructor_declaration(CSharpParser.Constructor_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMethod_declaration(CSharpParser.Method_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMethod_declaration(CSharpParser.Method_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMethod_member_name(CSharpParser.Method_member_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMethod_member_name(CSharpParser.Method_member_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOperator_declaration(CSharpParser.Operator_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOperator_declaration(CSharpParser.Operator_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArg_declaration(CSharpParser.Arg_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArg_declaration(CSharpParser.Arg_declarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMethod_invocation(CSharpParser.Method_invocationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMethod_invocation(CSharpParser.Method_invocationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterObject_creation_expression(CSharpParser.Object_creation_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitObject_creation_expression(CSharpParser.Object_creation_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIdentifier(CSharpParser.IdentifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIdentifier(CSharpParser.IdentifierContext ctx) { } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void visitTerminal(TerminalNode node) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void visitErrorNode(ErrorNode node) { } +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpParserListener.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpParserListener.java new file mode 100644 index 0000000000..cf9321a748 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/antlr/CSharpParserListener.java @@ -0,0 +1,2644 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.antlr; + +// Generated from CSharpParser.g4 by ANTLR 4.9.2 +import org.antlr.v4.runtime.tree.ParseTreeListener; + +/** + * This interface defines a complete listener for a parse tree produced by + * {@link CSharpParser}. + */ +public interface CSharpParserListener extends ParseTreeListener { + /** + * Enter a parse tree produced by {@link CSharpParser#compilation_unit}. + * @param ctx the parse tree + */ + void enterCompilation_unit(CSharpParser.Compilation_unitContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#compilation_unit}. + * @param ctx the parse tree + */ + void exitCompilation_unit(CSharpParser.Compilation_unitContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#namespace_or_type_name}. + * @param ctx the parse tree + */ + void enterNamespace_or_type_name(CSharpParser.Namespace_or_type_nameContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#namespace_or_type_name}. + * @param ctx the parse tree + */ + void exitNamespace_or_type_name(CSharpParser.Namespace_or_type_nameContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#type_}. + * @param ctx the parse tree + */ + void enterType_(CSharpParser.Type_Context ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#type_}. + * @param ctx the parse tree + */ + void exitType_(CSharpParser.Type_Context ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#base_type}. + * @param ctx the parse tree + */ + void enterBase_type(CSharpParser.Base_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#base_type}. + * @param ctx the parse tree + */ + void exitBase_type(CSharpParser.Base_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#tuple_type}. + * @param ctx the parse tree + */ + void enterTuple_type(CSharpParser.Tuple_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#tuple_type}. + * @param ctx the parse tree + */ + void exitTuple_type(CSharpParser.Tuple_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#tuple_element}. + * @param ctx the parse tree + */ + void enterTuple_element(CSharpParser.Tuple_elementContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#tuple_element}. + * @param ctx the parse tree + */ + void exitTuple_element(CSharpParser.Tuple_elementContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#simple_type}. + * @param ctx the parse tree + */ + void enterSimple_type(CSharpParser.Simple_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#simple_type}. + * @param ctx the parse tree + */ + void exitSimple_type(CSharpParser.Simple_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#numeric_type}. + * @param ctx the parse tree + */ + void enterNumeric_type(CSharpParser.Numeric_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#numeric_type}. + * @param ctx the parse tree + */ + void exitNumeric_type(CSharpParser.Numeric_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#integral_type}. + * @param ctx the parse tree + */ + void enterIntegral_type(CSharpParser.Integral_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#integral_type}. + * @param ctx the parse tree + */ + void exitIntegral_type(CSharpParser.Integral_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#floating_point_type}. + * @param ctx the parse tree + */ + void enterFloating_point_type(CSharpParser.Floating_point_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#floating_point_type}. + * @param ctx the parse tree + */ + void exitFloating_point_type(CSharpParser.Floating_point_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#class_type}. + * @param ctx the parse tree + */ + void enterClass_type(CSharpParser.Class_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#class_type}. + * @param ctx the parse tree + */ + void exitClass_type(CSharpParser.Class_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#type_argument_list}. + * @param ctx the parse tree + */ + void enterType_argument_list(CSharpParser.Type_argument_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#type_argument_list}. + * @param ctx the parse tree + */ + void exitType_argument_list(CSharpParser.Type_argument_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#argument_list}. + * @param ctx the parse tree + */ + void enterArgument_list(CSharpParser.Argument_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#argument_list}. + * @param ctx the parse tree + */ + void exitArgument_list(CSharpParser.Argument_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#argument}. + * @param ctx the parse tree + */ + void enterArgument(CSharpParser.ArgumentContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#argument}. + * @param ctx the parse tree + */ + void exitArgument(CSharpParser.ArgumentContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#expression}. + * @param ctx the parse tree + */ + void enterExpression(CSharpParser.ExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#expression}. + * @param ctx the parse tree + */ + void exitExpression(CSharpParser.ExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#non_assignment_expression}. + * @param ctx the parse tree + */ + void enterNon_assignment_expression(CSharpParser.Non_assignment_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#non_assignment_expression}. + * @param ctx the parse tree + */ + void exitNon_assignment_expression(CSharpParser.Non_assignment_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#assignment}. + * @param ctx the parse tree + */ + void enterAssignment(CSharpParser.AssignmentContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#assignment}. + * @param ctx the parse tree + */ + void exitAssignment(CSharpParser.AssignmentContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#assignment_operator}. + * @param ctx the parse tree + */ + void enterAssignment_operator(CSharpParser.Assignment_operatorContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#assignment_operator}. + * @param ctx the parse tree + */ + void exitAssignment_operator(CSharpParser.Assignment_operatorContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#conditional_expression}. + * @param ctx the parse tree + */ + void enterConditional_expression(CSharpParser.Conditional_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#conditional_expression}. + * @param ctx the parse tree + */ + void exitConditional_expression(CSharpParser.Conditional_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#null_coalescing_expression}. + * @param ctx the parse tree + */ + void enterNull_coalescing_expression(CSharpParser.Null_coalescing_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#null_coalescing_expression}. + * @param ctx the parse tree + */ + void exitNull_coalescing_expression(CSharpParser.Null_coalescing_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#conditional_or_expression}. + * @param ctx the parse tree + */ + void enterConditional_or_expression(CSharpParser.Conditional_or_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#conditional_or_expression}. + * @param ctx the parse tree + */ + void exitConditional_or_expression(CSharpParser.Conditional_or_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#conditional_and_expression}. + * @param ctx the parse tree + */ + void enterConditional_and_expression(CSharpParser.Conditional_and_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#conditional_and_expression}. + * @param ctx the parse tree + */ + void exitConditional_and_expression(CSharpParser.Conditional_and_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#inclusive_or_expression}. + * @param ctx the parse tree + */ + void enterInclusive_or_expression(CSharpParser.Inclusive_or_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#inclusive_or_expression}. + * @param ctx the parse tree + */ + void exitInclusive_or_expression(CSharpParser.Inclusive_or_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#exclusive_or_expression}. + * @param ctx the parse tree + */ + void enterExclusive_or_expression(CSharpParser.Exclusive_or_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#exclusive_or_expression}. + * @param ctx the parse tree + */ + void exitExclusive_or_expression(CSharpParser.Exclusive_or_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#and_expression}. + * @param ctx the parse tree + */ + void enterAnd_expression(CSharpParser.And_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#and_expression}. + * @param ctx the parse tree + */ + void exitAnd_expression(CSharpParser.And_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#equality_expression}. + * @param ctx the parse tree + */ + void enterEquality_expression(CSharpParser.Equality_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#equality_expression}. + * @param ctx the parse tree + */ + void exitEquality_expression(CSharpParser.Equality_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#relational_expression}. + * @param ctx the parse tree + */ + void enterRelational_expression(CSharpParser.Relational_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#relational_expression}. + * @param ctx the parse tree + */ + void exitRelational_expression(CSharpParser.Relational_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#shift_expression}. + * @param ctx the parse tree + */ + void enterShift_expression(CSharpParser.Shift_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#shift_expression}. + * @param ctx the parse tree + */ + void exitShift_expression(CSharpParser.Shift_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#additive_expression}. + * @param ctx the parse tree + */ + void enterAdditive_expression(CSharpParser.Additive_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#additive_expression}. + * @param ctx the parse tree + */ + void exitAdditive_expression(CSharpParser.Additive_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#multiplicative_expression}. + * @param ctx the parse tree + */ + void enterMultiplicative_expression(CSharpParser.Multiplicative_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#multiplicative_expression}. + * @param ctx the parse tree + */ + void exitMultiplicative_expression(CSharpParser.Multiplicative_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#switch_expression}. + * @param ctx the parse tree + */ + void enterSwitch_expression(CSharpParser.Switch_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#switch_expression}. + * @param ctx the parse tree + */ + void exitSwitch_expression(CSharpParser.Switch_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#switch_expression_arms}. + * @param ctx the parse tree + */ + void enterSwitch_expression_arms(CSharpParser.Switch_expression_armsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#switch_expression_arms}. + * @param ctx the parse tree + */ + void exitSwitch_expression_arms(CSharpParser.Switch_expression_armsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#switch_expression_arm}. + * @param ctx the parse tree + */ + void enterSwitch_expression_arm(CSharpParser.Switch_expression_armContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#switch_expression_arm}. + * @param ctx the parse tree + */ + void exitSwitch_expression_arm(CSharpParser.Switch_expression_armContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#range_expression}. + * @param ctx the parse tree + */ + void enterRange_expression(CSharpParser.Range_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#range_expression}. + * @param ctx the parse tree + */ + void exitRange_expression(CSharpParser.Range_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#unary_expression}. + * @param ctx the parse tree + */ + void enterUnary_expression(CSharpParser.Unary_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#unary_expression}. + * @param ctx the parse tree + */ + void exitUnary_expression(CSharpParser.Unary_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#primary_expression}. + * @param ctx the parse tree + */ + void enterPrimary_expression(CSharpParser.Primary_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#primary_expression}. + * @param ctx the parse tree + */ + void exitPrimary_expression(CSharpParser.Primary_expressionContext ctx); + /** + * Enter a parse tree produced by the {@code literalExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterLiteralExpression(CSharpParser.LiteralExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code literalExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitLiteralExpression(CSharpParser.LiteralExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code simpleNameExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterSimpleNameExpression(CSharpParser.SimpleNameExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code simpleNameExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitSimpleNameExpression(CSharpParser.SimpleNameExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code parenthesisExpressions} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterParenthesisExpressions(CSharpParser.ParenthesisExpressionsContext ctx); + /** + * Exit a parse tree produced by the {@code parenthesisExpressions} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitParenthesisExpressions(CSharpParser.ParenthesisExpressionsContext ctx); + /** + * Enter a parse tree produced by the {@code memberAccessExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterMemberAccessExpression(CSharpParser.MemberAccessExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code memberAccessExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitMemberAccessExpression(CSharpParser.MemberAccessExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code literalAccessExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterLiteralAccessExpression(CSharpParser.LiteralAccessExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code literalAccessExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitLiteralAccessExpression(CSharpParser.LiteralAccessExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code thisReferenceExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterThisReferenceExpression(CSharpParser.ThisReferenceExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code thisReferenceExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitThisReferenceExpression(CSharpParser.ThisReferenceExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code baseAccessExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterBaseAccessExpression(CSharpParser.BaseAccessExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code baseAccessExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitBaseAccessExpression(CSharpParser.BaseAccessExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code objectCreationExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterObjectCreationExpression(CSharpParser.ObjectCreationExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code objectCreationExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitObjectCreationExpression(CSharpParser.ObjectCreationExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code tupleExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterTupleExpression(CSharpParser.TupleExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code tupleExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitTupleExpression(CSharpParser.TupleExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code typeofExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterTypeofExpression(CSharpParser.TypeofExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code typeofExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitTypeofExpression(CSharpParser.TypeofExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code checkedExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterCheckedExpression(CSharpParser.CheckedExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code checkedExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitCheckedExpression(CSharpParser.CheckedExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code uncheckedExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterUncheckedExpression(CSharpParser.UncheckedExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code uncheckedExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitUncheckedExpression(CSharpParser.UncheckedExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code defaultValueExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterDefaultValueExpression(CSharpParser.DefaultValueExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code defaultValueExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitDefaultValueExpression(CSharpParser.DefaultValueExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code anonymousMethodExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterAnonymousMethodExpression(CSharpParser.AnonymousMethodExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code anonymousMethodExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitAnonymousMethodExpression(CSharpParser.AnonymousMethodExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code sizeofExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterSizeofExpression(CSharpParser.SizeofExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code sizeofExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitSizeofExpression(CSharpParser.SizeofExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code nameofExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void enterNameofExpression(CSharpParser.NameofExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code nameofExpression} + * labeled alternative in {@link CSharpParser#primary_expression_start}. + * @param ctx the parse tree + */ + void exitNameofExpression(CSharpParser.NameofExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#throwable_expression}. + * @param ctx the parse tree + */ + void enterThrowable_expression(CSharpParser.Throwable_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#throwable_expression}. + * @param ctx the parse tree + */ + void exitThrowable_expression(CSharpParser.Throwable_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#throw_expression}. + * @param ctx the parse tree + */ + void enterThrow_expression(CSharpParser.Throw_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#throw_expression}. + * @param ctx the parse tree + */ + void exitThrow_expression(CSharpParser.Throw_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#member_access}. + * @param ctx the parse tree + */ + void enterMember_access(CSharpParser.Member_accessContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#member_access}. + * @param ctx the parse tree + */ + void exitMember_access(CSharpParser.Member_accessContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#bracket_expression}. + * @param ctx the parse tree + */ + void enterBracket_expression(CSharpParser.Bracket_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#bracket_expression}. + * @param ctx the parse tree + */ + void exitBracket_expression(CSharpParser.Bracket_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#indexer_argument}. + * @param ctx the parse tree + */ + void enterIndexer_argument(CSharpParser.Indexer_argumentContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#indexer_argument}. + * @param ctx the parse tree + */ + void exitIndexer_argument(CSharpParser.Indexer_argumentContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#predefined_type}. + * @param ctx the parse tree + */ + void enterPredefined_type(CSharpParser.Predefined_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#predefined_type}. + * @param ctx the parse tree + */ + void exitPredefined_type(CSharpParser.Predefined_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#expression_list}. + * @param ctx the parse tree + */ + void enterExpression_list(CSharpParser.Expression_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#expression_list}. + * @param ctx the parse tree + */ + void exitExpression_list(CSharpParser.Expression_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#object_or_collection_initializer}. + * @param ctx the parse tree + */ + void enterObject_or_collection_initializer(CSharpParser.Object_or_collection_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#object_or_collection_initializer}. + * @param ctx the parse tree + */ + void exitObject_or_collection_initializer(CSharpParser.Object_or_collection_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#object_initializer}. + * @param ctx the parse tree + */ + void enterObject_initializer(CSharpParser.Object_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#object_initializer}. + * @param ctx the parse tree + */ + void exitObject_initializer(CSharpParser.Object_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#member_initializer_list}. + * @param ctx the parse tree + */ + void enterMember_initializer_list(CSharpParser.Member_initializer_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#member_initializer_list}. + * @param ctx the parse tree + */ + void exitMember_initializer_list(CSharpParser.Member_initializer_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#member_initializer}. + * @param ctx the parse tree + */ + void enterMember_initializer(CSharpParser.Member_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#member_initializer}. + * @param ctx the parse tree + */ + void exitMember_initializer(CSharpParser.Member_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#initializer_value}. + * @param ctx the parse tree + */ + void enterInitializer_value(CSharpParser.Initializer_valueContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#initializer_value}. + * @param ctx the parse tree + */ + void exitInitializer_value(CSharpParser.Initializer_valueContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#collection_initializer}. + * @param ctx the parse tree + */ + void enterCollection_initializer(CSharpParser.Collection_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#collection_initializer}. + * @param ctx the parse tree + */ + void exitCollection_initializer(CSharpParser.Collection_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#element_initializer}. + * @param ctx the parse tree + */ + void enterElement_initializer(CSharpParser.Element_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#element_initializer}. + * @param ctx the parse tree + */ + void exitElement_initializer(CSharpParser.Element_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#anonymous_object_initializer}. + * @param ctx the parse tree + */ + void enterAnonymous_object_initializer(CSharpParser.Anonymous_object_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#anonymous_object_initializer}. + * @param ctx the parse tree + */ + void exitAnonymous_object_initializer(CSharpParser.Anonymous_object_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#member_declarator_list}. + * @param ctx the parse tree + */ + void enterMember_declarator_list(CSharpParser.Member_declarator_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#member_declarator_list}. + * @param ctx the parse tree + */ + void exitMember_declarator_list(CSharpParser.Member_declarator_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#member_declarator}. + * @param ctx the parse tree + */ + void enterMember_declarator(CSharpParser.Member_declaratorContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#member_declarator}. + * @param ctx the parse tree + */ + void exitMember_declarator(CSharpParser.Member_declaratorContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#unbound_type_name}. + * @param ctx the parse tree + */ + void enterUnbound_type_name(CSharpParser.Unbound_type_nameContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#unbound_type_name}. + * @param ctx the parse tree + */ + void exitUnbound_type_name(CSharpParser.Unbound_type_nameContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#generic_dimension_specifier}. + * @param ctx the parse tree + */ + void enterGeneric_dimension_specifier(CSharpParser.Generic_dimension_specifierContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#generic_dimension_specifier}. + * @param ctx the parse tree + */ + void exitGeneric_dimension_specifier(CSharpParser.Generic_dimension_specifierContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#isType}. + * @param ctx the parse tree + */ + void enterIsType(CSharpParser.IsTypeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#isType}. + * @param ctx the parse tree + */ + void exitIsType(CSharpParser.IsTypeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#isTypePatternArms}. + * @param ctx the parse tree + */ + void enterIsTypePatternArms(CSharpParser.IsTypePatternArmsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#isTypePatternArms}. + * @param ctx the parse tree + */ + void exitIsTypePatternArms(CSharpParser.IsTypePatternArmsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#isTypePatternArm}. + * @param ctx the parse tree + */ + void enterIsTypePatternArm(CSharpParser.IsTypePatternArmContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#isTypePatternArm}. + * @param ctx the parse tree + */ + void exitIsTypePatternArm(CSharpParser.IsTypePatternArmContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#lambda_expression}. + * @param ctx the parse tree + */ + void enterLambda_expression(CSharpParser.Lambda_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#lambda_expression}. + * @param ctx the parse tree + */ + void exitLambda_expression(CSharpParser.Lambda_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#anonymous_function_signature}. + * @param ctx the parse tree + */ + void enterAnonymous_function_signature(CSharpParser.Anonymous_function_signatureContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#anonymous_function_signature}. + * @param ctx the parse tree + */ + void exitAnonymous_function_signature(CSharpParser.Anonymous_function_signatureContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#explicit_anonymous_function_parameter_list}. + * @param ctx the parse tree + */ + void enterExplicit_anonymous_function_parameter_list(CSharpParser.Explicit_anonymous_function_parameter_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#explicit_anonymous_function_parameter_list}. + * @param ctx the parse tree + */ + void exitExplicit_anonymous_function_parameter_list(CSharpParser.Explicit_anonymous_function_parameter_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#explicit_anonymous_function_parameter}. + * @param ctx the parse tree + */ + void enterExplicit_anonymous_function_parameter(CSharpParser.Explicit_anonymous_function_parameterContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#explicit_anonymous_function_parameter}. + * @param ctx the parse tree + */ + void exitExplicit_anonymous_function_parameter(CSharpParser.Explicit_anonymous_function_parameterContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#implicit_anonymous_function_parameter_list}. + * @param ctx the parse tree + */ + void enterImplicit_anonymous_function_parameter_list(CSharpParser.Implicit_anonymous_function_parameter_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#implicit_anonymous_function_parameter_list}. + * @param ctx the parse tree + */ + void exitImplicit_anonymous_function_parameter_list(CSharpParser.Implicit_anonymous_function_parameter_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#anonymous_function_body}. + * @param ctx the parse tree + */ + void enterAnonymous_function_body(CSharpParser.Anonymous_function_bodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#anonymous_function_body}. + * @param ctx the parse tree + */ + void exitAnonymous_function_body(CSharpParser.Anonymous_function_bodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#query_expression}. + * @param ctx the parse tree + */ + void enterQuery_expression(CSharpParser.Query_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#query_expression}. + * @param ctx the parse tree + */ + void exitQuery_expression(CSharpParser.Query_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#from_clause}. + * @param ctx the parse tree + */ + void enterFrom_clause(CSharpParser.From_clauseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#from_clause}. + * @param ctx the parse tree + */ + void exitFrom_clause(CSharpParser.From_clauseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#query_body}. + * @param ctx the parse tree + */ + void enterQuery_body(CSharpParser.Query_bodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#query_body}. + * @param ctx the parse tree + */ + void exitQuery_body(CSharpParser.Query_bodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#query_body_clause}. + * @param ctx the parse tree + */ + void enterQuery_body_clause(CSharpParser.Query_body_clauseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#query_body_clause}. + * @param ctx the parse tree + */ + void exitQuery_body_clause(CSharpParser.Query_body_clauseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#let_clause}. + * @param ctx the parse tree + */ + void enterLet_clause(CSharpParser.Let_clauseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#let_clause}. + * @param ctx the parse tree + */ + void exitLet_clause(CSharpParser.Let_clauseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#where_clause}. + * @param ctx the parse tree + */ + void enterWhere_clause(CSharpParser.Where_clauseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#where_clause}. + * @param ctx the parse tree + */ + void exitWhere_clause(CSharpParser.Where_clauseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#combined_join_clause}. + * @param ctx the parse tree + */ + void enterCombined_join_clause(CSharpParser.Combined_join_clauseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#combined_join_clause}. + * @param ctx the parse tree + */ + void exitCombined_join_clause(CSharpParser.Combined_join_clauseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#orderby_clause}. + * @param ctx the parse tree + */ + void enterOrderby_clause(CSharpParser.Orderby_clauseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#orderby_clause}. + * @param ctx the parse tree + */ + void exitOrderby_clause(CSharpParser.Orderby_clauseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#ordering}. + * @param ctx the parse tree + */ + void enterOrdering(CSharpParser.OrderingContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#ordering}. + * @param ctx the parse tree + */ + void exitOrdering(CSharpParser.OrderingContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#select_or_group_clause}. + * @param ctx the parse tree + */ + void enterSelect_or_group_clause(CSharpParser.Select_or_group_clauseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#select_or_group_clause}. + * @param ctx the parse tree + */ + void exitSelect_or_group_clause(CSharpParser.Select_or_group_clauseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#query_continuation}. + * @param ctx the parse tree + */ + void enterQuery_continuation(CSharpParser.Query_continuationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#query_continuation}. + * @param ctx the parse tree + */ + void exitQuery_continuation(CSharpParser.Query_continuationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#statement}. + * @param ctx the parse tree + */ + void enterStatement(CSharpParser.StatementContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#statement}. + * @param ctx the parse tree + */ + void exitStatement(CSharpParser.StatementContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#declarationStatement}. + * @param ctx the parse tree + */ + void enterDeclarationStatement(CSharpParser.DeclarationStatementContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#declarationStatement}. + * @param ctx the parse tree + */ + void exitDeclarationStatement(CSharpParser.DeclarationStatementContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#local_function_declaration}. + * @param ctx the parse tree + */ + void enterLocal_function_declaration(CSharpParser.Local_function_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#local_function_declaration}. + * @param ctx the parse tree + */ + void exitLocal_function_declaration(CSharpParser.Local_function_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#local_function_header}. + * @param ctx the parse tree + */ + void enterLocal_function_header(CSharpParser.Local_function_headerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#local_function_header}. + * @param ctx the parse tree + */ + void exitLocal_function_header(CSharpParser.Local_function_headerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#local_function_modifiers}. + * @param ctx the parse tree + */ + void enterLocal_function_modifiers(CSharpParser.Local_function_modifiersContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#local_function_modifiers}. + * @param ctx the parse tree + */ + void exitLocal_function_modifiers(CSharpParser.Local_function_modifiersContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#local_function_body}. + * @param ctx the parse tree + */ + void enterLocal_function_body(CSharpParser.Local_function_bodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#local_function_body}. + * @param ctx the parse tree + */ + void exitLocal_function_body(CSharpParser.Local_function_bodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#labeled_Statement}. + * @param ctx the parse tree + */ + void enterLabeled_Statement(CSharpParser.Labeled_StatementContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#labeled_Statement}. + * @param ctx the parse tree + */ + void exitLabeled_Statement(CSharpParser.Labeled_StatementContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#embedded_statement}. + * @param ctx the parse tree + */ + void enterEmbedded_statement(CSharpParser.Embedded_statementContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#embedded_statement}. + * @param ctx the parse tree + */ + void exitEmbedded_statement(CSharpParser.Embedded_statementContext ctx); + /** + * Enter a parse tree produced by the {@code theEmptyStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterTheEmptyStatement(CSharpParser.TheEmptyStatementContext ctx); + /** + * Exit a parse tree produced by the {@code theEmptyStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitTheEmptyStatement(CSharpParser.TheEmptyStatementContext ctx); + /** + * Enter a parse tree produced by the {@code expressionStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterExpressionStatement(CSharpParser.ExpressionStatementContext ctx); + /** + * Exit a parse tree produced by the {@code expressionStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitExpressionStatement(CSharpParser.ExpressionStatementContext ctx); + /** + * Enter a parse tree produced by the {@code ifStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterIfStatement(CSharpParser.IfStatementContext ctx); + /** + * Exit a parse tree produced by the {@code ifStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitIfStatement(CSharpParser.IfStatementContext ctx); + /** + * Enter a parse tree produced by the {@code switchStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterSwitchStatement(CSharpParser.SwitchStatementContext ctx); + /** + * Exit a parse tree produced by the {@code switchStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitSwitchStatement(CSharpParser.SwitchStatementContext ctx); + /** + * Enter a parse tree produced by the {@code whileStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterWhileStatement(CSharpParser.WhileStatementContext ctx); + /** + * Exit a parse tree produced by the {@code whileStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitWhileStatement(CSharpParser.WhileStatementContext ctx); + /** + * Enter a parse tree produced by the {@code doStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterDoStatement(CSharpParser.DoStatementContext ctx); + /** + * Exit a parse tree produced by the {@code doStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitDoStatement(CSharpParser.DoStatementContext ctx); + /** + * Enter a parse tree produced by the {@code forStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterForStatement(CSharpParser.ForStatementContext ctx); + /** + * Exit a parse tree produced by the {@code forStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitForStatement(CSharpParser.ForStatementContext ctx); + /** + * Enter a parse tree produced by the {@code foreachStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterForeachStatement(CSharpParser.ForeachStatementContext ctx); + /** + * Exit a parse tree produced by the {@code foreachStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitForeachStatement(CSharpParser.ForeachStatementContext ctx); + /** + * Enter a parse tree produced by the {@code breakStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterBreakStatement(CSharpParser.BreakStatementContext ctx); + /** + * Exit a parse tree produced by the {@code breakStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitBreakStatement(CSharpParser.BreakStatementContext ctx); + /** + * Enter a parse tree produced by the {@code continueStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterContinueStatement(CSharpParser.ContinueStatementContext ctx); + /** + * Exit a parse tree produced by the {@code continueStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitContinueStatement(CSharpParser.ContinueStatementContext ctx); + /** + * Enter a parse tree produced by the {@code gotoStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterGotoStatement(CSharpParser.GotoStatementContext ctx); + /** + * Exit a parse tree produced by the {@code gotoStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitGotoStatement(CSharpParser.GotoStatementContext ctx); + /** + * Enter a parse tree produced by the {@code returnStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterReturnStatement(CSharpParser.ReturnStatementContext ctx); + /** + * Exit a parse tree produced by the {@code returnStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitReturnStatement(CSharpParser.ReturnStatementContext ctx); + /** + * Enter a parse tree produced by the {@code throwStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterThrowStatement(CSharpParser.ThrowStatementContext ctx); + /** + * Exit a parse tree produced by the {@code throwStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitThrowStatement(CSharpParser.ThrowStatementContext ctx); + /** + * Enter a parse tree produced by the {@code tryStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterTryStatement(CSharpParser.TryStatementContext ctx); + /** + * Exit a parse tree produced by the {@code tryStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitTryStatement(CSharpParser.TryStatementContext ctx); + /** + * Enter a parse tree produced by the {@code checkedStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterCheckedStatement(CSharpParser.CheckedStatementContext ctx); + /** + * Exit a parse tree produced by the {@code checkedStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitCheckedStatement(CSharpParser.CheckedStatementContext ctx); + /** + * Enter a parse tree produced by the {@code uncheckedStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterUncheckedStatement(CSharpParser.UncheckedStatementContext ctx); + /** + * Exit a parse tree produced by the {@code uncheckedStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitUncheckedStatement(CSharpParser.UncheckedStatementContext ctx); + /** + * Enter a parse tree produced by the {@code lockStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterLockStatement(CSharpParser.LockStatementContext ctx); + /** + * Exit a parse tree produced by the {@code lockStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitLockStatement(CSharpParser.LockStatementContext ctx); + /** + * Enter a parse tree produced by the {@code usingStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterUsingStatement(CSharpParser.UsingStatementContext ctx); + /** + * Exit a parse tree produced by the {@code usingStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitUsingStatement(CSharpParser.UsingStatementContext ctx); + /** + * Enter a parse tree produced by the {@code yieldStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterYieldStatement(CSharpParser.YieldStatementContext ctx); + /** + * Exit a parse tree produced by the {@code yieldStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitYieldStatement(CSharpParser.YieldStatementContext ctx); + /** + * Enter a parse tree produced by the {@code unsafeStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterUnsafeStatement(CSharpParser.UnsafeStatementContext ctx); + /** + * Exit a parse tree produced by the {@code unsafeStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitUnsafeStatement(CSharpParser.UnsafeStatementContext ctx); + /** + * Enter a parse tree produced by the {@code fixedStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void enterFixedStatement(CSharpParser.FixedStatementContext ctx); + /** + * Exit a parse tree produced by the {@code fixedStatement} + * labeled alternative in {@link CSharpParser#simple_embedded_statement}. + * @param ctx the parse tree + */ + void exitFixedStatement(CSharpParser.FixedStatementContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#block}. + * @param ctx the parse tree + */ + void enterBlock(CSharpParser.BlockContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#block}. + * @param ctx the parse tree + */ + void exitBlock(CSharpParser.BlockContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#local_variable_declaration}. + * @param ctx the parse tree + */ + void enterLocal_variable_declaration(CSharpParser.Local_variable_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#local_variable_declaration}. + * @param ctx the parse tree + */ + void exitLocal_variable_declaration(CSharpParser.Local_variable_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#local_variable_type}. + * @param ctx the parse tree + */ + void enterLocal_variable_type(CSharpParser.Local_variable_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#local_variable_type}. + * @param ctx the parse tree + */ + void exitLocal_variable_type(CSharpParser.Local_variable_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#local_variable_declarator}. + * @param ctx the parse tree + */ + void enterLocal_variable_declarator(CSharpParser.Local_variable_declaratorContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#local_variable_declarator}. + * @param ctx the parse tree + */ + void exitLocal_variable_declarator(CSharpParser.Local_variable_declaratorContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#local_variable_initializer}. + * @param ctx the parse tree + */ + void enterLocal_variable_initializer(CSharpParser.Local_variable_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#local_variable_initializer}. + * @param ctx the parse tree + */ + void exitLocal_variable_initializer(CSharpParser.Local_variable_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#local_constant_declaration}. + * @param ctx the parse tree + */ + void enterLocal_constant_declaration(CSharpParser.Local_constant_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#local_constant_declaration}. + * @param ctx the parse tree + */ + void exitLocal_constant_declaration(CSharpParser.Local_constant_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#if_body}. + * @param ctx the parse tree + */ + void enterIf_body(CSharpParser.If_bodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#if_body}. + * @param ctx the parse tree + */ + void exitIf_body(CSharpParser.If_bodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#switch_section}. + * @param ctx the parse tree + */ + void enterSwitch_section(CSharpParser.Switch_sectionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#switch_section}. + * @param ctx the parse tree + */ + void exitSwitch_section(CSharpParser.Switch_sectionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#switch_label}. + * @param ctx the parse tree + */ + void enterSwitch_label(CSharpParser.Switch_labelContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#switch_label}. + * @param ctx the parse tree + */ + void exitSwitch_label(CSharpParser.Switch_labelContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#case_guard}. + * @param ctx the parse tree + */ + void enterCase_guard(CSharpParser.Case_guardContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#case_guard}. + * @param ctx the parse tree + */ + void exitCase_guard(CSharpParser.Case_guardContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#statement_list}. + * @param ctx the parse tree + */ + void enterStatement_list(CSharpParser.Statement_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#statement_list}. + * @param ctx the parse tree + */ + void exitStatement_list(CSharpParser.Statement_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#for_initializer}. + * @param ctx the parse tree + */ + void enterFor_initializer(CSharpParser.For_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#for_initializer}. + * @param ctx the parse tree + */ + void exitFor_initializer(CSharpParser.For_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#for_iterator}. + * @param ctx the parse tree + */ + void enterFor_iterator(CSharpParser.For_iteratorContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#for_iterator}. + * @param ctx the parse tree + */ + void exitFor_iterator(CSharpParser.For_iteratorContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#catch_clauses}. + * @param ctx the parse tree + */ + void enterCatch_clauses(CSharpParser.Catch_clausesContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#catch_clauses}. + * @param ctx the parse tree + */ + void exitCatch_clauses(CSharpParser.Catch_clausesContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#specific_catch_clause}. + * @param ctx the parse tree + */ + void enterSpecific_catch_clause(CSharpParser.Specific_catch_clauseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#specific_catch_clause}. + * @param ctx the parse tree + */ + void exitSpecific_catch_clause(CSharpParser.Specific_catch_clauseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#general_catch_clause}. + * @param ctx the parse tree + */ + void enterGeneral_catch_clause(CSharpParser.General_catch_clauseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#general_catch_clause}. + * @param ctx the parse tree + */ + void exitGeneral_catch_clause(CSharpParser.General_catch_clauseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#exception_filter}. + * @param ctx the parse tree + */ + void enterException_filter(CSharpParser.Exception_filterContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#exception_filter}. + * @param ctx the parse tree + */ + void exitException_filter(CSharpParser.Exception_filterContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#finally_clause}. + * @param ctx the parse tree + */ + void enterFinally_clause(CSharpParser.Finally_clauseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#finally_clause}. + * @param ctx the parse tree + */ + void exitFinally_clause(CSharpParser.Finally_clauseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#resource_acquisition}. + * @param ctx the parse tree + */ + void enterResource_acquisition(CSharpParser.Resource_acquisitionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#resource_acquisition}. + * @param ctx the parse tree + */ + void exitResource_acquisition(CSharpParser.Resource_acquisitionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#namespace_declaration}. + * @param ctx the parse tree + */ + void enterNamespace_declaration(CSharpParser.Namespace_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#namespace_declaration}. + * @param ctx the parse tree + */ + void exitNamespace_declaration(CSharpParser.Namespace_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#qualified_identifier}. + * @param ctx the parse tree + */ + void enterQualified_identifier(CSharpParser.Qualified_identifierContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#qualified_identifier}. + * @param ctx the parse tree + */ + void exitQualified_identifier(CSharpParser.Qualified_identifierContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#namespace_body}. + * @param ctx the parse tree + */ + void enterNamespace_body(CSharpParser.Namespace_bodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#namespace_body}. + * @param ctx the parse tree + */ + void exitNamespace_body(CSharpParser.Namespace_bodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#extern_alias_directives}. + * @param ctx the parse tree + */ + void enterExtern_alias_directives(CSharpParser.Extern_alias_directivesContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#extern_alias_directives}. + * @param ctx the parse tree + */ + void exitExtern_alias_directives(CSharpParser.Extern_alias_directivesContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#extern_alias_directive}. + * @param ctx the parse tree + */ + void enterExtern_alias_directive(CSharpParser.Extern_alias_directiveContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#extern_alias_directive}. + * @param ctx the parse tree + */ + void exitExtern_alias_directive(CSharpParser.Extern_alias_directiveContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#using_directives}. + * @param ctx the parse tree + */ + void enterUsing_directives(CSharpParser.Using_directivesContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#using_directives}. + * @param ctx the parse tree + */ + void exitUsing_directives(CSharpParser.Using_directivesContext ctx); + /** + * Enter a parse tree produced by the {@code usingAliasDirective} + * labeled alternative in {@link CSharpParser#using_directive}. + * @param ctx the parse tree + */ + void enterUsingAliasDirective(CSharpParser.UsingAliasDirectiveContext ctx); + /** + * Exit a parse tree produced by the {@code usingAliasDirective} + * labeled alternative in {@link CSharpParser#using_directive}. + * @param ctx the parse tree + */ + void exitUsingAliasDirective(CSharpParser.UsingAliasDirectiveContext ctx); + /** + * Enter a parse tree produced by the {@code usingNamespaceDirective} + * labeled alternative in {@link CSharpParser#using_directive}. + * @param ctx the parse tree + */ + void enterUsingNamespaceDirective(CSharpParser.UsingNamespaceDirectiveContext ctx); + /** + * Exit a parse tree produced by the {@code usingNamespaceDirective} + * labeled alternative in {@link CSharpParser#using_directive}. + * @param ctx the parse tree + */ + void exitUsingNamespaceDirective(CSharpParser.UsingNamespaceDirectiveContext ctx); + /** + * Enter a parse tree produced by the {@code usingStaticDirective} + * labeled alternative in {@link CSharpParser#using_directive}. + * @param ctx the parse tree + */ + void enterUsingStaticDirective(CSharpParser.UsingStaticDirectiveContext ctx); + /** + * Exit a parse tree produced by the {@code usingStaticDirective} + * labeled alternative in {@link CSharpParser#using_directive}. + * @param ctx the parse tree + */ + void exitUsingStaticDirective(CSharpParser.UsingStaticDirectiveContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#namespace_member_declarations}. + * @param ctx the parse tree + */ + void enterNamespace_member_declarations(CSharpParser.Namespace_member_declarationsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#namespace_member_declarations}. + * @param ctx the parse tree + */ + void exitNamespace_member_declarations(CSharpParser.Namespace_member_declarationsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#namespace_member_declaration}. + * @param ctx the parse tree + */ + void enterNamespace_member_declaration(CSharpParser.Namespace_member_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#namespace_member_declaration}. + * @param ctx the parse tree + */ + void exitNamespace_member_declaration(CSharpParser.Namespace_member_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#type_declaration}. + * @param ctx the parse tree + */ + void enterType_declaration(CSharpParser.Type_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#type_declaration}. + * @param ctx the parse tree + */ + void exitType_declaration(CSharpParser.Type_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#qualified_alias_member}. + * @param ctx the parse tree + */ + void enterQualified_alias_member(CSharpParser.Qualified_alias_memberContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#qualified_alias_member}. + * @param ctx the parse tree + */ + void exitQualified_alias_member(CSharpParser.Qualified_alias_memberContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#type_parameter_list}. + * @param ctx the parse tree + */ + void enterType_parameter_list(CSharpParser.Type_parameter_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#type_parameter_list}. + * @param ctx the parse tree + */ + void exitType_parameter_list(CSharpParser.Type_parameter_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#type_parameter}. + * @param ctx the parse tree + */ + void enterType_parameter(CSharpParser.Type_parameterContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#type_parameter}. + * @param ctx the parse tree + */ + void exitType_parameter(CSharpParser.Type_parameterContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#class_base}. + * @param ctx the parse tree + */ + void enterClass_base(CSharpParser.Class_baseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#class_base}. + * @param ctx the parse tree + */ + void exitClass_base(CSharpParser.Class_baseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#interface_type_list}. + * @param ctx the parse tree + */ + void enterInterface_type_list(CSharpParser.Interface_type_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#interface_type_list}. + * @param ctx the parse tree + */ + void exitInterface_type_list(CSharpParser.Interface_type_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#type_parameter_constraints_clauses}. + * @param ctx the parse tree + */ + void enterType_parameter_constraints_clauses(CSharpParser.Type_parameter_constraints_clausesContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#type_parameter_constraints_clauses}. + * @param ctx the parse tree + */ + void exitType_parameter_constraints_clauses(CSharpParser.Type_parameter_constraints_clausesContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#type_parameter_constraints_clause}. + * @param ctx the parse tree + */ + void enterType_parameter_constraints_clause(CSharpParser.Type_parameter_constraints_clauseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#type_parameter_constraints_clause}. + * @param ctx the parse tree + */ + void exitType_parameter_constraints_clause(CSharpParser.Type_parameter_constraints_clauseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#type_parameter_constraints}. + * @param ctx the parse tree + */ + void enterType_parameter_constraints(CSharpParser.Type_parameter_constraintsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#type_parameter_constraints}. + * @param ctx the parse tree + */ + void exitType_parameter_constraints(CSharpParser.Type_parameter_constraintsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#primary_constraint}. + * @param ctx the parse tree + */ + void enterPrimary_constraint(CSharpParser.Primary_constraintContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#primary_constraint}. + * @param ctx the parse tree + */ + void exitPrimary_constraint(CSharpParser.Primary_constraintContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#secondary_constraints}. + * @param ctx the parse tree + */ + void enterSecondary_constraints(CSharpParser.Secondary_constraintsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#secondary_constraints}. + * @param ctx the parse tree + */ + void exitSecondary_constraints(CSharpParser.Secondary_constraintsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#constructor_constraint}. + * @param ctx the parse tree + */ + void enterConstructor_constraint(CSharpParser.Constructor_constraintContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#constructor_constraint}. + * @param ctx the parse tree + */ + void exitConstructor_constraint(CSharpParser.Constructor_constraintContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#class_body}. + * @param ctx the parse tree + */ + void enterClass_body(CSharpParser.Class_bodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#class_body}. + * @param ctx the parse tree + */ + void exitClass_body(CSharpParser.Class_bodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#class_member_declarations}. + * @param ctx the parse tree + */ + void enterClass_member_declarations(CSharpParser.Class_member_declarationsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#class_member_declarations}. + * @param ctx the parse tree + */ + void exitClass_member_declarations(CSharpParser.Class_member_declarationsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#class_member_declaration}. + * @param ctx the parse tree + */ + void enterClass_member_declaration(CSharpParser.Class_member_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#class_member_declaration}. + * @param ctx the parse tree + */ + void exitClass_member_declaration(CSharpParser.Class_member_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#all_member_modifiers}. + * @param ctx the parse tree + */ + void enterAll_member_modifiers(CSharpParser.All_member_modifiersContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#all_member_modifiers}. + * @param ctx the parse tree + */ + void exitAll_member_modifiers(CSharpParser.All_member_modifiersContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#all_member_modifier}. + * @param ctx the parse tree + */ + void enterAll_member_modifier(CSharpParser.All_member_modifierContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#all_member_modifier}. + * @param ctx the parse tree + */ + void exitAll_member_modifier(CSharpParser.All_member_modifierContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#common_member_declaration}. + * @param ctx the parse tree + */ + void enterCommon_member_declaration(CSharpParser.Common_member_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#common_member_declaration}. + * @param ctx the parse tree + */ + void exitCommon_member_declaration(CSharpParser.Common_member_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#typed_member_declaration}. + * @param ctx the parse tree + */ + void enterTyped_member_declaration(CSharpParser.Typed_member_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#typed_member_declaration}. + * @param ctx the parse tree + */ + void exitTyped_member_declaration(CSharpParser.Typed_member_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#constant_declarators}. + * @param ctx the parse tree + */ + void enterConstant_declarators(CSharpParser.Constant_declaratorsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#constant_declarators}. + * @param ctx the parse tree + */ + void exitConstant_declarators(CSharpParser.Constant_declaratorsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#constant_declarator}. + * @param ctx the parse tree + */ + void enterConstant_declarator(CSharpParser.Constant_declaratorContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#constant_declarator}. + * @param ctx the parse tree + */ + void exitConstant_declarator(CSharpParser.Constant_declaratorContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#variable_declarators}. + * @param ctx the parse tree + */ + void enterVariable_declarators(CSharpParser.Variable_declaratorsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#variable_declarators}. + * @param ctx the parse tree + */ + void exitVariable_declarators(CSharpParser.Variable_declaratorsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#variable_declarator}. + * @param ctx the parse tree + */ + void enterVariable_declarator(CSharpParser.Variable_declaratorContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#variable_declarator}. + * @param ctx the parse tree + */ + void exitVariable_declarator(CSharpParser.Variable_declaratorContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#variable_initializer}. + * @param ctx the parse tree + */ + void enterVariable_initializer(CSharpParser.Variable_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#variable_initializer}. + * @param ctx the parse tree + */ + void exitVariable_initializer(CSharpParser.Variable_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#return_type}. + * @param ctx the parse tree + */ + void enterReturn_type(CSharpParser.Return_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#return_type}. + * @param ctx the parse tree + */ + void exitReturn_type(CSharpParser.Return_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#member_name}. + * @param ctx the parse tree + */ + void enterMember_name(CSharpParser.Member_nameContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#member_name}. + * @param ctx the parse tree + */ + void exitMember_name(CSharpParser.Member_nameContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#method_body}. + * @param ctx the parse tree + */ + void enterMethod_body(CSharpParser.Method_bodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#method_body}. + * @param ctx the parse tree + */ + void exitMethod_body(CSharpParser.Method_bodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#formal_parameter_list}. + * @param ctx the parse tree + */ + void enterFormal_parameter_list(CSharpParser.Formal_parameter_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#formal_parameter_list}. + * @param ctx the parse tree + */ + void exitFormal_parameter_list(CSharpParser.Formal_parameter_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#fixed_parameters}. + * @param ctx the parse tree + */ + void enterFixed_parameters(CSharpParser.Fixed_parametersContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#fixed_parameters}. + * @param ctx the parse tree + */ + void exitFixed_parameters(CSharpParser.Fixed_parametersContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#fixed_parameter}. + * @param ctx the parse tree + */ + void enterFixed_parameter(CSharpParser.Fixed_parameterContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#fixed_parameter}. + * @param ctx the parse tree + */ + void exitFixed_parameter(CSharpParser.Fixed_parameterContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#parameter_modifier}. + * @param ctx the parse tree + */ + void enterParameter_modifier(CSharpParser.Parameter_modifierContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#parameter_modifier}. + * @param ctx the parse tree + */ + void exitParameter_modifier(CSharpParser.Parameter_modifierContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#parameter_array}. + * @param ctx the parse tree + */ + void enterParameter_array(CSharpParser.Parameter_arrayContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#parameter_array}. + * @param ctx the parse tree + */ + void exitParameter_array(CSharpParser.Parameter_arrayContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#accessor_declarations}. + * @param ctx the parse tree + */ + void enterAccessor_declarations(CSharpParser.Accessor_declarationsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#accessor_declarations}. + * @param ctx the parse tree + */ + void exitAccessor_declarations(CSharpParser.Accessor_declarationsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#get_accessor_declaration}. + * @param ctx the parse tree + */ + void enterGet_accessor_declaration(CSharpParser.Get_accessor_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#get_accessor_declaration}. + * @param ctx the parse tree + */ + void exitGet_accessor_declaration(CSharpParser.Get_accessor_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#set_accessor_declaration}. + * @param ctx the parse tree + */ + void enterSet_accessor_declaration(CSharpParser.Set_accessor_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#set_accessor_declaration}. + * @param ctx the parse tree + */ + void exitSet_accessor_declaration(CSharpParser.Set_accessor_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#accessor_modifier}. + * @param ctx the parse tree + */ + void enterAccessor_modifier(CSharpParser.Accessor_modifierContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#accessor_modifier}. + * @param ctx the parse tree + */ + void exitAccessor_modifier(CSharpParser.Accessor_modifierContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#accessor_body}. + * @param ctx the parse tree + */ + void enterAccessor_body(CSharpParser.Accessor_bodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#accessor_body}. + * @param ctx the parse tree + */ + void exitAccessor_body(CSharpParser.Accessor_bodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#event_accessor_declarations}. + * @param ctx the parse tree + */ + void enterEvent_accessor_declarations(CSharpParser.Event_accessor_declarationsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#event_accessor_declarations}. + * @param ctx the parse tree + */ + void exitEvent_accessor_declarations(CSharpParser.Event_accessor_declarationsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#add_accessor_declaration}. + * @param ctx the parse tree + */ + void enterAdd_accessor_declaration(CSharpParser.Add_accessor_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#add_accessor_declaration}. + * @param ctx the parse tree + */ + void exitAdd_accessor_declaration(CSharpParser.Add_accessor_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#remove_accessor_declaration}. + * @param ctx the parse tree + */ + void enterRemove_accessor_declaration(CSharpParser.Remove_accessor_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#remove_accessor_declaration}. + * @param ctx the parse tree + */ + void exitRemove_accessor_declaration(CSharpParser.Remove_accessor_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#overloadable_operator}. + * @param ctx the parse tree + */ + void enterOverloadable_operator(CSharpParser.Overloadable_operatorContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#overloadable_operator}. + * @param ctx the parse tree + */ + void exitOverloadable_operator(CSharpParser.Overloadable_operatorContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#conversion_operator_declarator}. + * @param ctx the parse tree + */ + void enterConversion_operator_declarator(CSharpParser.Conversion_operator_declaratorContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#conversion_operator_declarator}. + * @param ctx the parse tree + */ + void exitConversion_operator_declarator(CSharpParser.Conversion_operator_declaratorContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#constructor_initializer}. + * @param ctx the parse tree + */ + void enterConstructor_initializer(CSharpParser.Constructor_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#constructor_initializer}. + * @param ctx the parse tree + */ + void exitConstructor_initializer(CSharpParser.Constructor_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#body}. + * @param ctx the parse tree + */ + void enterBody(CSharpParser.BodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#body}. + * @param ctx the parse tree + */ + void exitBody(CSharpParser.BodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#struct_interfaces}. + * @param ctx the parse tree + */ + void enterStruct_interfaces(CSharpParser.Struct_interfacesContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#struct_interfaces}. + * @param ctx the parse tree + */ + void exitStruct_interfaces(CSharpParser.Struct_interfacesContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#struct_body}. + * @param ctx the parse tree + */ + void enterStruct_body(CSharpParser.Struct_bodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#struct_body}. + * @param ctx the parse tree + */ + void exitStruct_body(CSharpParser.Struct_bodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#struct_member_declaration}. + * @param ctx the parse tree + */ + void enterStruct_member_declaration(CSharpParser.Struct_member_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#struct_member_declaration}. + * @param ctx the parse tree + */ + void exitStruct_member_declaration(CSharpParser.Struct_member_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#array_type}. + * @param ctx the parse tree + */ + void enterArray_type(CSharpParser.Array_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#array_type}. + * @param ctx the parse tree + */ + void exitArray_type(CSharpParser.Array_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#rank_specifier}. + * @param ctx the parse tree + */ + void enterRank_specifier(CSharpParser.Rank_specifierContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#rank_specifier}. + * @param ctx the parse tree + */ + void exitRank_specifier(CSharpParser.Rank_specifierContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#array_initializer}. + * @param ctx the parse tree + */ + void enterArray_initializer(CSharpParser.Array_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#array_initializer}. + * @param ctx the parse tree + */ + void exitArray_initializer(CSharpParser.Array_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#variant_type_parameter_list}. + * @param ctx the parse tree + */ + void enterVariant_type_parameter_list(CSharpParser.Variant_type_parameter_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#variant_type_parameter_list}. + * @param ctx the parse tree + */ + void exitVariant_type_parameter_list(CSharpParser.Variant_type_parameter_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#variant_type_parameter}. + * @param ctx the parse tree + */ + void enterVariant_type_parameter(CSharpParser.Variant_type_parameterContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#variant_type_parameter}. + * @param ctx the parse tree + */ + void exitVariant_type_parameter(CSharpParser.Variant_type_parameterContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#variance_annotation}. + * @param ctx the parse tree + */ + void enterVariance_annotation(CSharpParser.Variance_annotationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#variance_annotation}. + * @param ctx the parse tree + */ + void exitVariance_annotation(CSharpParser.Variance_annotationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#interface_base}. + * @param ctx the parse tree + */ + void enterInterface_base(CSharpParser.Interface_baseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#interface_base}. + * @param ctx the parse tree + */ + void exitInterface_base(CSharpParser.Interface_baseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#interface_body}. + * @param ctx the parse tree + */ + void enterInterface_body(CSharpParser.Interface_bodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#interface_body}. + * @param ctx the parse tree + */ + void exitInterface_body(CSharpParser.Interface_bodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#interface_member_declaration}. + * @param ctx the parse tree + */ + void enterInterface_member_declaration(CSharpParser.Interface_member_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#interface_member_declaration}. + * @param ctx the parse tree + */ + void exitInterface_member_declaration(CSharpParser.Interface_member_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#interface_accessors}. + * @param ctx the parse tree + */ + void enterInterface_accessors(CSharpParser.Interface_accessorsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#interface_accessors}. + * @param ctx the parse tree + */ + void exitInterface_accessors(CSharpParser.Interface_accessorsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#enum_base}. + * @param ctx the parse tree + */ + void enterEnum_base(CSharpParser.Enum_baseContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#enum_base}. + * @param ctx the parse tree + */ + void exitEnum_base(CSharpParser.Enum_baseContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#enum_body}. + * @param ctx the parse tree + */ + void enterEnum_body(CSharpParser.Enum_bodyContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#enum_body}. + * @param ctx the parse tree + */ + void exitEnum_body(CSharpParser.Enum_bodyContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#enum_member_declaration}. + * @param ctx the parse tree + */ + void enterEnum_member_declaration(CSharpParser.Enum_member_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#enum_member_declaration}. + * @param ctx the parse tree + */ + void exitEnum_member_declaration(CSharpParser.Enum_member_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#global_attribute_section}. + * @param ctx the parse tree + */ + void enterGlobal_attribute_section(CSharpParser.Global_attribute_sectionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#global_attribute_section}. + * @param ctx the parse tree + */ + void exitGlobal_attribute_section(CSharpParser.Global_attribute_sectionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#global_attribute_target}. + * @param ctx the parse tree + */ + void enterGlobal_attribute_target(CSharpParser.Global_attribute_targetContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#global_attribute_target}. + * @param ctx the parse tree + */ + void exitGlobal_attribute_target(CSharpParser.Global_attribute_targetContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#attributes}. + * @param ctx the parse tree + */ + void enterAttributes(CSharpParser.AttributesContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#attributes}. + * @param ctx the parse tree + */ + void exitAttributes(CSharpParser.AttributesContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#attribute_section}. + * @param ctx the parse tree + */ + void enterAttribute_section(CSharpParser.Attribute_sectionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#attribute_section}. + * @param ctx the parse tree + */ + void exitAttribute_section(CSharpParser.Attribute_sectionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#attribute_target}. + * @param ctx the parse tree + */ + void enterAttribute_target(CSharpParser.Attribute_targetContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#attribute_target}. + * @param ctx the parse tree + */ + void exitAttribute_target(CSharpParser.Attribute_targetContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#attribute_list}. + * @param ctx the parse tree + */ + void enterAttribute_list(CSharpParser.Attribute_listContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#attribute_list}. + * @param ctx the parse tree + */ + void exitAttribute_list(CSharpParser.Attribute_listContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#attribute}. + * @param ctx the parse tree + */ + void enterAttribute(CSharpParser.AttributeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#attribute}. + * @param ctx the parse tree + */ + void exitAttribute(CSharpParser.AttributeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#attribute_argument}. + * @param ctx the parse tree + */ + void enterAttribute_argument(CSharpParser.Attribute_argumentContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#attribute_argument}. + * @param ctx the parse tree + */ + void exitAttribute_argument(CSharpParser.Attribute_argumentContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#pointer_type}. + * @param ctx the parse tree + */ + void enterPointer_type(CSharpParser.Pointer_typeContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#pointer_type}. + * @param ctx the parse tree + */ + void exitPointer_type(CSharpParser.Pointer_typeContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#fixed_pointer_declarators}. + * @param ctx the parse tree + */ + void enterFixed_pointer_declarators(CSharpParser.Fixed_pointer_declaratorsContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#fixed_pointer_declarators}. + * @param ctx the parse tree + */ + void exitFixed_pointer_declarators(CSharpParser.Fixed_pointer_declaratorsContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#fixed_pointer_declarator}. + * @param ctx the parse tree + */ + void enterFixed_pointer_declarator(CSharpParser.Fixed_pointer_declaratorContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#fixed_pointer_declarator}. + * @param ctx the parse tree + */ + void exitFixed_pointer_declarator(CSharpParser.Fixed_pointer_declaratorContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#fixed_pointer_initializer}. + * @param ctx the parse tree + */ + void enterFixed_pointer_initializer(CSharpParser.Fixed_pointer_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#fixed_pointer_initializer}. + * @param ctx the parse tree + */ + void exitFixed_pointer_initializer(CSharpParser.Fixed_pointer_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#fixed_size_buffer_declarator}. + * @param ctx the parse tree + */ + void enterFixed_size_buffer_declarator(CSharpParser.Fixed_size_buffer_declaratorContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#fixed_size_buffer_declarator}. + * @param ctx the parse tree + */ + void exitFixed_size_buffer_declarator(CSharpParser.Fixed_size_buffer_declaratorContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#stackalloc_initializer}. + * @param ctx the parse tree + */ + void enterStackalloc_initializer(CSharpParser.Stackalloc_initializerContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#stackalloc_initializer}. + * @param ctx the parse tree + */ + void exitStackalloc_initializer(CSharpParser.Stackalloc_initializerContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#right_arrow}. + * @param ctx the parse tree + */ + void enterRight_arrow(CSharpParser.Right_arrowContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#right_arrow}. + * @param ctx the parse tree + */ + void exitRight_arrow(CSharpParser.Right_arrowContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#right_shift}. + * @param ctx the parse tree + */ + void enterRight_shift(CSharpParser.Right_shiftContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#right_shift}. + * @param ctx the parse tree + */ + void exitRight_shift(CSharpParser.Right_shiftContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#right_shift_assignment}. + * @param ctx the parse tree + */ + void enterRight_shift_assignment(CSharpParser.Right_shift_assignmentContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#right_shift_assignment}. + * @param ctx the parse tree + */ + void exitRight_shift_assignment(CSharpParser.Right_shift_assignmentContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#literal}. + * @param ctx the parse tree + */ + void enterLiteral(CSharpParser.LiteralContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#literal}. + * @param ctx the parse tree + */ + void exitLiteral(CSharpParser.LiteralContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#boolean_literal}. + * @param ctx the parse tree + */ + void enterBoolean_literal(CSharpParser.Boolean_literalContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#boolean_literal}. + * @param ctx the parse tree + */ + void exitBoolean_literal(CSharpParser.Boolean_literalContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#string_literal}. + * @param ctx the parse tree + */ + void enterString_literal(CSharpParser.String_literalContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#string_literal}. + * @param ctx the parse tree + */ + void exitString_literal(CSharpParser.String_literalContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#interpolated_regular_string}. + * @param ctx the parse tree + */ + void enterInterpolated_regular_string(CSharpParser.Interpolated_regular_stringContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#interpolated_regular_string}. + * @param ctx the parse tree + */ + void exitInterpolated_regular_string(CSharpParser.Interpolated_regular_stringContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#interpolated_verbatium_string}. + * @param ctx the parse tree + */ + void enterInterpolated_verbatium_string(CSharpParser.Interpolated_verbatium_stringContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#interpolated_verbatium_string}. + * @param ctx the parse tree + */ + void exitInterpolated_verbatium_string(CSharpParser.Interpolated_verbatium_stringContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#interpolated_regular_string_part}. + * @param ctx the parse tree + */ + void enterInterpolated_regular_string_part(CSharpParser.Interpolated_regular_string_partContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#interpolated_regular_string_part}. + * @param ctx the parse tree + */ + void exitInterpolated_regular_string_part(CSharpParser.Interpolated_regular_string_partContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#interpolated_verbatium_string_part}. + * @param ctx the parse tree + */ + void enterInterpolated_verbatium_string_part(CSharpParser.Interpolated_verbatium_string_partContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#interpolated_verbatium_string_part}. + * @param ctx the parse tree + */ + void exitInterpolated_verbatium_string_part(CSharpParser.Interpolated_verbatium_string_partContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#interpolated_string_expression}. + * @param ctx the parse tree + */ + void enterInterpolated_string_expression(CSharpParser.Interpolated_string_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#interpolated_string_expression}. + * @param ctx the parse tree + */ + void exitInterpolated_string_expression(CSharpParser.Interpolated_string_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#keyword}. + * @param ctx the parse tree + */ + void enterKeyword(CSharpParser.KeywordContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#keyword}. + * @param ctx the parse tree + */ + void exitKeyword(CSharpParser.KeywordContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#class_definition}. + * @param ctx the parse tree + */ + void enterClass_definition(CSharpParser.Class_definitionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#class_definition}. + * @param ctx the parse tree + */ + void exitClass_definition(CSharpParser.Class_definitionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#struct_definition}. + * @param ctx the parse tree + */ + void enterStruct_definition(CSharpParser.Struct_definitionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#struct_definition}. + * @param ctx the parse tree + */ + void exitStruct_definition(CSharpParser.Struct_definitionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#interface_definition}. + * @param ctx the parse tree + */ + void enterInterface_definition(CSharpParser.Interface_definitionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#interface_definition}. + * @param ctx the parse tree + */ + void exitInterface_definition(CSharpParser.Interface_definitionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#enum_definition}. + * @param ctx the parse tree + */ + void enterEnum_definition(CSharpParser.Enum_definitionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#enum_definition}. + * @param ctx the parse tree + */ + void exitEnum_definition(CSharpParser.Enum_definitionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#delegate_definition}. + * @param ctx the parse tree + */ + void enterDelegate_definition(CSharpParser.Delegate_definitionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#delegate_definition}. + * @param ctx the parse tree + */ + void exitDelegate_definition(CSharpParser.Delegate_definitionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#event_declaration}. + * @param ctx the parse tree + */ + void enterEvent_declaration(CSharpParser.Event_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#event_declaration}. + * @param ctx the parse tree + */ + void exitEvent_declaration(CSharpParser.Event_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#field_declaration}. + * @param ctx the parse tree + */ + void enterField_declaration(CSharpParser.Field_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#field_declaration}. + * @param ctx the parse tree + */ + void exitField_declaration(CSharpParser.Field_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#property_declaration}. + * @param ctx the parse tree + */ + void enterProperty_declaration(CSharpParser.Property_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#property_declaration}. + * @param ctx the parse tree + */ + void exitProperty_declaration(CSharpParser.Property_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#constant_declaration}. + * @param ctx the parse tree + */ + void enterConstant_declaration(CSharpParser.Constant_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#constant_declaration}. + * @param ctx the parse tree + */ + void exitConstant_declaration(CSharpParser.Constant_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#indexer_declaration}. + * @param ctx the parse tree + */ + void enterIndexer_declaration(CSharpParser.Indexer_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#indexer_declaration}. + * @param ctx the parse tree + */ + void exitIndexer_declaration(CSharpParser.Indexer_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#destructor_definition}. + * @param ctx the parse tree + */ + void enterDestructor_definition(CSharpParser.Destructor_definitionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#destructor_definition}. + * @param ctx the parse tree + */ + void exitDestructor_definition(CSharpParser.Destructor_definitionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#constructor_declaration}. + * @param ctx the parse tree + */ + void enterConstructor_declaration(CSharpParser.Constructor_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#constructor_declaration}. + * @param ctx the parse tree + */ + void exitConstructor_declaration(CSharpParser.Constructor_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#method_declaration}. + * @param ctx the parse tree + */ + void enterMethod_declaration(CSharpParser.Method_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#method_declaration}. + * @param ctx the parse tree + */ + void exitMethod_declaration(CSharpParser.Method_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#method_member_name}. + * @param ctx the parse tree + */ + void enterMethod_member_name(CSharpParser.Method_member_nameContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#method_member_name}. + * @param ctx the parse tree + */ + void exitMethod_member_name(CSharpParser.Method_member_nameContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#operator_declaration}. + * @param ctx the parse tree + */ + void enterOperator_declaration(CSharpParser.Operator_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#operator_declaration}. + * @param ctx the parse tree + */ + void exitOperator_declaration(CSharpParser.Operator_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#arg_declaration}. + * @param ctx the parse tree + */ + void enterArg_declaration(CSharpParser.Arg_declarationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#arg_declaration}. + * @param ctx the parse tree + */ + void exitArg_declaration(CSharpParser.Arg_declarationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#method_invocation}. + * @param ctx the parse tree + */ + void enterMethod_invocation(CSharpParser.Method_invocationContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#method_invocation}. + * @param ctx the parse tree + */ + void exitMethod_invocation(CSharpParser.Method_invocationContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#object_creation_expression}. + * @param ctx the parse tree + */ + void enterObject_creation_expression(CSharpParser.Object_creation_expressionContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#object_creation_expression}. + * @param ctx the parse tree + */ + void exitObject_creation_expression(CSharpParser.Object_creation_expressionContext ctx); + /** + * Enter a parse tree produced by {@link CSharpParser#identifier}. + * @param ctx the parse tree + */ + void enterIdentifier(CSharpParser.IdentifierContext ctx); + /** + * Exit a parse tree produced by {@link CSharpParser#identifier}. + * @param ctx the parse tree + */ + void exitIdentifier(CSharpParser.IdentifierContext ctx); +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydafny/DafnyApiCodegenTest.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydafny/DafnyApiCodegenTest.java new file mode 100644 index 0000000000..892ecee37c --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydafny/DafnyApiCodegenTest.java @@ -0,0 +1,398 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydafny; + +import org.junit.Test; +import software.amazon.polymorph.util.TestModel; +import software.amazon.polymorph.util.Tokenizer; +import software.amazon.polymorph.util.Tokenizer.ParseToken; +import software.amazon.polymorph.utils.TokenTree; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.loader.ModelAssembler; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StructureShape; + +import java.nio.file.Path; +import java.util.List; +import java.util.Map; +import java.util.function.BiConsumer; + +import static org.junit.Assert.*; +import static software.amazon.polymorph.util.TestModel.SERVICE_NAMESPACE; +import static software.amazon.polymorph.util.TestModel.SERVICE_SHAPE_ID; + +// TODO: use Dafny tokenizer instead of C# tokenizer +public class DafnyApiCodegenTest { + private static DafnyApiCodegen setupCodegen(final BiConsumer updater) { + final Model model = TestModel.setupModel(updater); + return new DafnyApiCodegen(model, SERVICE_SHAPE_ID); + } + + @Test + public void testGenerate() { + final ShapeId operationShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "DoIt"); + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> { + builder.addOperation(operationShapeId); + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + operation DoIt {} + boolean SomeBool + @enum([{name: "A", value: "A"}, {name: "B", value: "B"}]) string SomeEnum + long SomeLong + list SomeList { member: String } + structure SomeStructure { someInt: Integer } + map EncryptionContextType { key: EncryptionContextKey, value: EncryptionContextValue } + @aws.polymorph#dafnyUtf8Bytes string EncryptionContextKey + @aws.polymorph#dafnyUtf8Bytes string EncryptionContextValue + """.formatted(SERVICE_NAMESPACE)); + }); + final Map codeByPath = codegen.generate(); + final String actualCode = codeByPath.get(Path.of("FoobarService.dfy")).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + include "../StandardLibrary/StandardLibrary.dfy" + include "../Util/UTF8.dfy" + module {:extern "Dafny.Test.Foobar"} Test.Foobar { + import opened Wrappers + import opened StandardLibrary.UInt + import opened UTF8 + type EncryptionContextKey = ValidUTF8Bytes + type EncryptionContextType = map + type EncryptionContextValue = ValidUTF8Bytes + trait IFoobarServiceClient { + predicate {:opaque} DoItCalledWith() {true} + predicate {:opaque} DoItSucceededWith() {true} + method DoIt() returns (output: Result<(), FoobarServiceError>) + ensures DoItCalledWith() + ensures output.Success? ==> DoItSucceededWith() + } + datatype FoobarServiceError = + | FoobarService_Unknown(unknownMessage: string) + function method CastFoobarServiceErrorToString (error: FoobarServiceError): string { + match error + case FoobarService_Unknown(arg) => "Unexpected Exception from AWS FoobarService: " + arg + } + type SomeBool = bool + datatype SomeEnum = | A | B + type SomeList = seq + type SomeLong = int64 + datatype SomeStructure = SomeStructure(nameonly someInt: Option) + } + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateBlobTypeDefinition() { + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + @length(min: 1, max: 1024) + blob SomeBlob + """.formatted(SERVICE_NAMESPACE))); + final String actualCode = codegen.generateBlobTypeDefinition( + ShapeId.fromParts(SERVICE_NAMESPACE, "SomeBlob")).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + type SomeBlob = x: seq | IsValid_SomeBlob(x) witness * + predicate method IsValid_SomeBlob(x: seq) { (1 <= |x| <= 1024) } + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateBoolTypeDefinition() { + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + boolean SomeBool + """.formatted(SERVICE_NAMESPACE))); + final String actualCode = codegen.generateBoolTypeDefinition( + ShapeId.fromParts(SERVICE_NAMESPACE, "SomeBool")).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize("type SomeBool = bool"); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateStringTypeDefinition() { + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + @length(min: 1, max: 1024) + string SomeString + """.formatted(SERVICE_NAMESPACE))); + final String actualCode = codegen.generateStringTypeDefinition( + ShapeId.fromParts(SERVICE_NAMESPACE, "SomeString")).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + type SomeString = x: string | IsValid_SomeString(x) witness * + predicate method IsValid_SomeString(x: string) { (1 <= |x| <= 1024) } + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateEnumTypeDefinition() { + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + @enum([ + {value: "V1", name: "N1"}, + {value: "V2", name: "N2"}, + {value: "V3", name: "N3"}, + ]) + string SomeEnum + """.formatted(SERVICE_NAMESPACE))); + final String actualCode = codegen.generateEnumTypeDefinition( + ShapeId.fromParts(SERVICE_NAMESPACE, "SomeEnum")).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize("datatype SomeEnum = | N1 | N2 | N3"); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateNumericTypeDefinitionInt() { + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + @range(min: 1, max: 10) + integer SomeInt + """.formatted(SERVICE_NAMESPACE))); + + final String actualCode = codegen.generateNumericTypeDefinition( + ShapeId.fromParts(SERVICE_NAMESPACE, "SomeInt")).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + type SomeInt = x: int32 | IsValid_SomeInt(x) witness * + predicate method IsValid_SomeInt(x: int32) { (1 <= x <= 10) } + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateNumericTypeDefinitionLong() { + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + @range(min: 1, max: 10) + long SomeLong + """.formatted(SERVICE_NAMESPACE))); + + final String actualCode = codegen.generateNumericTypeDefinition( + ShapeId.fromParts(SERVICE_NAMESPACE, "SomeLong")).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + type SomeLong = x: int64 | IsValid_SomeLong(x) witness * + predicate method IsValid_SomeLong(x: int64) { (1 <= x <= 10) } + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateListTypeDefinition() { + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + @length(min: 1, max: 10) + list SomeList { + member: Boolean + } + """.formatted(SERVICE_NAMESPACE))); + final String actualCode = codegen.generateListTypeDefinition( + ShapeId.fromParts(SERVICE_NAMESPACE, "SomeList")).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + type SomeList = x: seq | IsValid_SomeList(x) witness * + predicate method IsValid_SomeList(x: seq) { (1 <= |x| <= 10) } + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateMapTypeDefinition() { + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + @length(min: 1, max: 10) + map SomeMap { + key: String, + value: Boolean, + } + """.formatted(SERVICE_NAMESPACE))); + final String actualCode = codegen.generateMapTypeDefinition( + ShapeId.fromParts(SERVICE_NAMESPACE, "SomeMap")).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + type SomeMap = x: map | IsValid_SomeMap(x) witness * + predicate method IsValid_SomeMap(x: map) { (1 <= |x| <= 10) } + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateStructureTypeDefinition() { + final StructureShape foobarStructureShape = TestModel.setupFoobarStructureShape(); + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addShape(foobarStructureShape)); + + final String actualCode = codegen.generateStructureTypeDefinition(foobarStructureShape.getId()).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + datatype Foobar = Foobar( + nameonly someInt: Option, + nameonly someString: Option, + nameonly someBool: bool + ) + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateServiceTraitDefinition() { + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> { + builder.addOperation(ShapeId.fromParts(SERVICE_NAMESPACE, "DoThis")); + builder.addOperation(ShapeId.fromParts(SERVICE_NAMESPACE, "DoThat")); + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + operation DoThis {} + operation DoThat {} + """.formatted(SERVICE_NAMESPACE)); + }); + final String actualCode = codegen.generateServiceTraitDefinition().toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + trait IFoobarServiceClient { + predicate {:opaque} DoThisCalledWith() {true} + predicate {:opaque} DoThisSucceededWith() {true} + method DoThis() returns (output: Result<(), FoobarServiceError>) + ensures DoThisCalledWith() + ensures output.Success? ==> DoThisSucceededWith() + predicate {:opaque} DoThatCalledWith() {true} + predicate {:opaque} DoThatSucceededWith() {true} + method DoThat() returns (output: Result<(), FoobarServiceError>) + ensures DoThatCalledWith() + ensures output.Success? ==> DoThatSucceededWith() + }"""); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateOperationPredicatesAndMethod() { + final ShapeId operationShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "DoIt"); + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> { + builder.addOperation(operationShapeId); + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + operation DoIt { input: Foo, output: Bar, errors: [Oops] } + structure Foo {} + structure Bar {} + @error("client") structure Oops {} + """.formatted(SERVICE_NAMESPACE)); + }); + final String actualCode = codegen.generateOperationPredicatesAndMethod(operationShapeId).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + predicate {:opaque} DoItCalledWith( + input: Foo + ) {true} + predicate {:opaque} DoItSucceededWith( + input: Foo, + output: Bar + ) {true} + method DoIt(input: Foo) returns (output: Result) + ensures DoItCalledWith(input) + ensures output.Success? ==> DoItSucceededWith(input, output.value) + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateServiceErrorTypeDefinition() { + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> { + builder.addOperation(ShapeId.fromParts(SERVICE_NAMESPACE, "DoIt")); + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + operation DoIt { errors: [Oops, OhNo, Whoops] } + @error("client") structure Oops {} + @error("client") structure OhNo {} + @error("server") structure Whoops {} + """.formatted(SERVICE_NAMESPACE)); + }); + final String actualCode = codegen.generateServiceErrorTypeDefinition().toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + datatype FoobarServiceError = + | FoobarService_Unknown(unknownMessage: string) + | FoobarService_OhNo(OhNo: OhNo) + | FoobarService_Oops(Oops: Oops) + | FoobarService_Whoops(Whoops: Whoops) + function method CastFoobarServiceErrorToString (error: FoobarServiceError): string { + match error + case FoobarService_OhNo(arg) => arg.CastToString() + case FoobarService_Oops(arg) => arg.CastToString() + case FoobarService_Whoops(arg) => arg.CastToString() + case FoobarService_Unknown(arg) => "Unexpected Exception from AWS FoobarService: " + arg + } + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateErrorStructureTypeDefinition_WithMessage() { + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Oops"); + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> { + builder.addOperation(ShapeId.fromParts(SERVICE_NAMESPACE, "DoIt")); + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + string ErrorMessageType + operation DoIt { errors: [Oops, OhNo] } + @error("client") structure Oops { message: ErrorMessageType,} + @error("server") structure OhNo {} + """.formatted(SERVICE_NAMESPACE)); + }); + final String actualCode = codegen.generateErrorStructureTypeDefinition(shapeId).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + final List expectedTokens = Tokenizer.tokenize(""" + datatype Oops = Oops ( + nameonly message: Option ) { + function method CastToString(): string { + if message.Some? then "Oops: " + message.value else "Oops" + } + } + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateErrorStructureTypeDefinition_WithOutMessage() { + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "OhNo"); + final DafnyApiCodegen codegen = setupCodegen((builder, modelAssembler) -> { + builder.addOperation(ShapeId.fromParts(SERVICE_NAMESPACE, "DoIt")); + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + string ErrorMessageType + operation DoIt { errors: [Oops, OhNo] } + @error("client") structure Oops { message: ErrorMessageType,} + @error("server") structure OhNo {} + """.formatted(SERVICE_NAMESPACE)); + }); + final String actualCode = codegen.generateErrorStructureTypeDefinition(shapeId).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + final List expectedTokens = Tokenizer.tokenize(""" + datatype OhNo = OhNo () { + function method CastToString(): string { + "OhNo" + } + } + """); + assertEquals(expectedTokens, actualTokens); + } +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/AwsSdkShimCodegenTest.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/AwsSdkShimCodegenTest.java new file mode 100644 index 0000000000..28c2aba3fb --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/AwsSdkShimCodegenTest.java @@ -0,0 +1,214 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import org.junit.Test; +import software.amazon.polymorph.util.TestModel; +import software.amazon.polymorph.util.Tokenizer; +import software.amazon.polymorph.util.Tokenizer.ParseToken; +import software.amazon.polymorph.utils.TokenTree; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.loader.ModelAssembler; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.ShapeId; + +import java.nio.file.Path; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.BiConsumer; + +import static org.junit.Assert.assertEquals; +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.FROM_DAFNY; +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.TO_DAFNY; + +public class AwsSdkShimCodegenTest { + private static final String SERVICE_NAMESPACE = "com.amazonaws.foobar"; + private static final String SERVICE_NAME = "FoobarService"; + private static final ShapeId SERVICE_SHAPE_ID = ShapeId.fromParts(SERVICE_NAMESPACE, SERVICE_NAME); + + private static AwsSdkShimCodegen setupCodegen(final BiConsumer updater) { + final Model model = TestModel.setupModel((builder, assembler) -> { + builder.id(SERVICE_SHAPE_ID); + updater.accept(builder, assembler); + }); + return new AwsSdkShimCodegen(model, SERVICE_SHAPE_ID); + } + + @Test + public void testGenerateEmptyService() { + final AwsSdkShimCodegen codegen = setupCodegen((_builder, _modelAssembler) -> {}); + final Map codeByPath = codegen.generate(); + final Path shimPath = Path.of("FoobarServiceShim.cs"); + assert codeByPath.keySet().equals(Set.of(shimPath)); + + final List actualTokens = Tokenizer.tokenize(codeByPath.get(shimPath).toString()); + + final String stringConverter = AwsSdkDotNetNameResolver.qualifiedTypeConverter( + ShapeId.from("smithy.api#String"), TO_DAFNY); + final List expectedTokens = Tokenizer.tokenize(""" + using System; + using System.IO; + using System.Collections.Generic; + + namespace Com.Amazonaws.Foobar { + internal class FoobarServiceShim : Dafny.Com.Amazonaws.Foobar.IFoobarServiceClient { + internal Amazon.FoobarService.AmazonFoobarServiceClient _impl; + + internal FoobarServiceShim(Amazon.FoobarService.AmazonFoobarServiceClient impl) { + this._impl = impl; + } + + private Dafny.Com.Amazonaws.Foobar.FoobarServiceError ConvertError( + Amazon.FoobarService.AmazonFoobarServiceException error) { + return Dafny.Com.Amazonaws.Foobar.FoobarServiceError.create_FoobarService__Unknown( + %s(error.Message)); + } + } + } + """.formatted(stringConverter)); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateServiceShim() { + final ShapeId inputOperation = ShapeId.fromParts(SERVICE_NAMESPACE, "DoInput"); + final ShapeId outputOperation = ShapeId.fromParts(SERVICE_NAMESPACE, "DoOutput"); + final AwsSdkShimCodegen codegen = setupCodegen((builder, modelAssembler) -> { + builder.addOperation(inputOperation); + builder.addOperation(outputOperation); + modelAssembler.addUnparsedModel("test.smithy", """ + namespace com.amazonaws.foobar + operation DoInput { + input: DoInputRequest, + errors: [Crash], + } + operation DoOutput { + output: DoOutputResponse, + errors: [Crash], + } + structure DoInputRequest {} + structure DoOutputResponse {} + @error("client") structure Crash { message: String } + """); + }); + final List actualTokens = Tokenizer.tokenize(codegen.generateServiceShim().toString()); + + final String expectedShimConstructor = codegen.generateServiceShimConstructor().toString(); + final String expectedInputOperationShim = codegen.generateOperationShim(inputOperation).toString(); + final String expectedOutputOperationShim = codegen.generateOperationShim(outputOperation).toString(); + final String expectedErrorTypeShim = codegen.generateErrorTypeShim().toString(); + final List expectedTokens = Tokenizer.tokenize(""" + namespace Com.Amazonaws.Foobar { + internal class FoobarServiceShim : Dafny.Com.Amazonaws.Foobar.IFoobarServiceClient { + internal Amazon.FoobarService.AmazonFoobarServiceClient _impl; + %s + %s + %s + %s + } + } + """.formatted( + expectedShimConstructor, + expectedInputOperationShim, + expectedOutputOperationShim, + expectedErrorTypeShim)); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateOperationShim() { + final ShapeId operationShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Go"); + final ShapeId requestShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "GoRequest"); + final ShapeId responseShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "GoResponse"); + final AwsSdkShimCodegen codegen = setupCodegen((builder, modelAssembler) -> { + builder.addOperation(operationShapeId); + modelAssembler.addUnparsedModel("test.smithy", """ + namespace com.amazonaws.foobar + operation Go { + input: GoRequest, + output: GoResponse, + errors: [Crash], + } + structure GoRequest {} + structure GoResponse {} + @error("client") structure Crash { message: String } + """); + }); + + final List actualTokens = Tokenizer.tokenize( + codegen.generateOperationShim(operationShapeId).toString()); + + final String resultType = "Wrappers_Compile.Result<%s, %s>" + .formatted("Dafny.Com.Amazonaws.Foobar.GoResponse", "Dafny.Com.Amazonaws.Foobar.FoobarServiceError"); + final String requestFromDafnyConverter = + AwsSdkDotNetNameResolver.qualifiedTypeConverter(requestShapeId, FROM_DAFNY); + final String responseToDafnyConverter = AwsSdkDotNetNameResolver.qualifiedTypeConverter(responseShapeId, TO_DAFNY); + final List expectedTokens = Tokenizer.tokenize(""" + public %1$s Go(Dafny.Com.Amazonaws.Foobar.GoRequest request) { + Amazon.FoobarService.Model.GoRequest sdkRequest = %2$s(request); + try { + Amazon.FoobarService.Model.GoResponse sdkResponse = + this._impl.GoAsync(sdkRequest).Result; + return %1$s.create_Success(%3$s(sdkResponse)); + } + catch (Amazon.FoobarService.AmazonFoobarServiceException ex) { + return %1$s.create_Failure(this.ConvertError(ex)); + } + } + """.formatted(resultType, requestFromDafnyConverter, responseToDafnyConverter)); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateErrorTypeShim() { + final ShapeId operationShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Go"); + final AwsSdkShimCodegen codegen = setupCodegen((builder, modelAssembler) -> { + builder.addOperation(operationShapeId); + modelAssembler.addUnparsedModel("test.smithy", """ + namespace com.amazonaws.foobar + operation Go { + errors: [Boom, Crash, Bang], + } + @error("client") structure Boom { message: String } + @error("client") structure Crash { message: String } + @error("client") structure Bang { message: String } + """); + }); + final List actualTokens = Tokenizer.tokenize(codegen.generateErrorTypeShim().toString()); + + final String bangConverter = AwsSdkDotNetNameResolver.qualifiedTypeConverter( + ShapeId.from("com.amazonaws.foobar#Bang"), TO_DAFNY); + final String boomConverter = AwsSdkDotNetNameResolver.qualifiedTypeConverter( + ShapeId.from("com.amazonaws.foobar#Boom"), TO_DAFNY); + final String crashConverter = AwsSdkDotNetNameResolver.qualifiedTypeConverter( + ShapeId.from("com.amazonaws.foobar#Crash"), TO_DAFNY); + final String stringConverter = AwsSdkDotNetNameResolver.qualifiedTypeConverter( + ShapeId.from("smithy.api#String"), TO_DAFNY); + final List expectedTokens = Tokenizer.tokenize(""" + private Dafny.Com.Amazonaws.Foobar.FoobarServiceError ConvertError( + Amazon.FoobarService.AmazonFoobarServiceException error) { + if (error is Amazon.FoobarService.Model.Bang) { + return Dafny.Com.Amazonaws.Foobar.FoobarServiceError.create_FoobarService__Bang( + %1$s((Amazon.FoobarService.Model.Bang) error)); + } + if (error is Amazon.FoobarService.Model.Boom) { + return Dafny.Com.Amazonaws.Foobar.FoobarServiceError.create_FoobarService__Boom( + %2$s((Amazon.FoobarService.Model.Boom) error)); + } + if (error is Amazon.FoobarService.Model.Crash) { + return Dafny.Com.Amazonaws.Foobar.FoobarServiceError.create_FoobarService__Crash( + %3$s((Amazon.FoobarService.Model.Crash) error)); + } + return Dafny.Com.Amazonaws.Foobar.FoobarServiceError.create_FoobarService__Unknown( + %4$s(error.Message)); + } + """.formatted(bangConverter, boomConverter, crashConverter, stringConverter)); + + assertEquals(expectedTokens, actualTokens); + } +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/AwsSdkTypeConversionCodegenTest.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/AwsSdkTypeConversionCodegenTest.java new file mode 100644 index 0000000000..9905f54aa5 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/AwsSdkTypeConversionCodegenTest.java @@ -0,0 +1,76 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import org.junit.Test; +import software.amazon.polymorph.util.TestModel; +import software.amazon.polymorph.util.Tokenizer; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.loader.ModelAssembler; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StructureShape; + +import java.util.List; +import java.util.function.BiConsumer; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.FROM_DAFNY; +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.TO_DAFNY; + +public class AwsSdkTypeConversionCodegenTest { + private static final String SERVICE_NAMESPACE = "com.amazonaws.foobar"; + private static final String SERVICE_NAME = "FoobarService"; + private static final ShapeId SERVICE_SHAPE_ID = ShapeId.fromParts(SERVICE_NAMESPACE, SERVICE_NAME); + + private static AwsSdkTypeConversionCodegen setupCodegen(final BiConsumer updater) { + final Model model = TestModel.setupModel((builder, assembler) -> { + builder.id(SERVICE_SHAPE_ID); + updater.accept(builder, assembler); + }); + return new AwsSdkTypeConversionCodegen(model, SERVICE_SHAPE_ID); + } + + @Test + public void testGenerateStructureConverterErrorStructureWithMessage() { + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "OopsException"); + final ShapeId stringShapeId = ShapeId.from("smithy.api#String"); + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + @error("client") + structure OopsException { message: String } + """.formatted(SERVICE_NAMESPACE))); + final TypeConversionCodegen.TypeConverter converter = codegen.generateStructureConverter( + codegen.getModel().expectShape(shapeId, StructureShape.class)); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String structureFromDafnyConverterName = AwsSdkDotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final String stringFromDafnyConverterName = AwsSdkDotNetNameResolver.typeConverterForShape(stringShapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static Amazon.FoobarService.Model.OopsException %s(Dafny.Com.Amazonaws.Foobar.OopsException value) { + string message = value.message.is_Some ? null : %s(value.message.Extract()); + return new Amazon.FoobarService.Model.OopsException(message); + }""".formatted( + structureFromDafnyConverterName, + stringFromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String structureToDafnyConverterName = AwsSdkDotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final String stringToDafnyConverterName = AwsSdkDotNetNameResolver.typeConverterForShape(stringShapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.Com.Amazonaws.Foobar.OopsException %s(Amazon.FoobarService.Model.OopsException value) { + Wrappers_Compile.Option> message = System.String.IsNullOrEmpty(value.Message) + ? Wrappers_Compile.Option>.create_None() + : Wrappers_Compile.Option>.create_Some(%s(value.Message)); + return new Dafny.Com.Amazonaws.Foobar.OopsException(message); + }""".formatted( + structureToDafnyConverterName, + stringToDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/DotNetNameResolverTest.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/DotNetNameResolverTest.java new file mode 100644 index 0000000000..c1edd3e199 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/DotNetNameResolverTest.java @@ -0,0 +1,191 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import org.junit.Test; +import software.amazon.polymorph.smithydafny.DafnyNameResolver; +import software.amazon.polymorph.traits.DafnyUtf8BytesTrait; +import software.amazon.polymorph.traits.PositionalTrait; +import software.amazon.polymorph.traits.ReferenceTrait; +import software.amazon.polymorph.util.TestModel; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.loader.ModelAssembler; +import software.amazon.smithy.model.shapes.ListShape; +import software.amazon.smithy.model.shapes.MapShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StringShape; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.EnumDefinition; +import software.amazon.smithy.model.traits.EnumTrait; + +import java.util.function.BiConsumer; + +import static org.junit.Assert.assertEquals; +import static software.amazon.polymorph.util.TestModel.SERVICE_NAMESPACE; +import static software.amazon.polymorph.util.TestModel.SERVICE_SHAPE_ID; + +public class DotNetNameResolverTest { + private DotNetNameResolver setupNameResolver(final BiConsumer updater) { + final Model model = TestModel.setupModel(updater); + final ServiceShape serviceShape = model.expectShape(SERVICE_SHAPE_ID, ServiceShape.class); + return new DotNetNameResolver(model, serviceShape); + } + + @Test + public void testEncodeShapeIdRoot() { + final ShapeId shapeId = ShapeId.fromParts("com.foo.bar_baz", "ShapeName"); + final String encodedShapeId = DotNetNameResolver.encodedIdentForShapeId(shapeId); + assertEquals(encodedShapeId, "N3_com__N3_foo__N7_bar_baz__S9_ShapeName"); + } + + @Test + public void testEncodeShapeIdWithMember() { + final ShapeId shapeId = ShapeId.fromParts("com.foo.bar_baz", "ShapeName", "MemberName"); + final String encodedShapeId = DotNetNameResolver.encodedIdentForShapeId(shapeId); + assertEquals(encodedShapeId, "N3_com__N3_foo__N7_bar_baz__S9_ShapeName__M10_MemberName"); + } + + @Test + public void testEncodeShapeIdWithSuspiciousIdents() { + final ShapeId shapeId = ShapeId.fromParts("N3_com__.__bar_baz.M10_MemberName", "N3_foo", "__SUS__S1__"); + final String encodedShapeId = DotNetNameResolver.encodedIdentForShapeId(shapeId); + assertEquals(encodedShapeId, "N8_N3_com____N9___bar_baz__N14_M10_MemberName__S6_N3_foo__M11___SUS__S1__"); + } + + @Test + public void testTypeConverterForShape() { + final StructureShape foobarStructureShape = TestModel.setupFoobarStructureShape(); + final DotNetNameResolver nameResolver = setupNameResolver( + (builder, modelAssembler) -> modelAssembler.addShape(foobarStructureShape)); + + final String toDafnyConverterName = DotNetNameResolver.typeConverterForShape(foobarStructureShape.getId(), + TypeConversionDirection.TO_DAFNY); + assertEquals("ToDafny_N4_test__N6_foobar__S6_Foobar", toDafnyConverterName); + + final String fromDafnyConverterName = DotNetNameResolver.typeConverterForShape(foobarStructureShape.getId(), + TypeConversionDirection.FROM_DAFNY); + assertEquals("FromDafny_N4_test__N6_foobar__S6_Foobar", fromDafnyConverterName); + } + + @Test + public void testDafnyNamespaceForShapeId() { + final ShapeId shapeId = ShapeId.fromParts("test.foobar.baz", "Whatever"); + final String dafnyNamespace = DafnyNameResolver.dafnyExternNamespaceForShapeId(shapeId); + assertEquals("Dafny.Test.Foobar.Baz", dafnyNamespace); + } + + @Test + public void testDafnyTypeForSimpleShapes() { + final DotNetNameResolver nameResolver = setupNameResolver((_builder, _modelAssembler) -> {}); + assertEquals("Dafny.ISequence", nameResolver.dafnyTypeForShape(ShapeId.from("smithy.api#Blob"))); + assertEquals("bool", nameResolver.dafnyTypeForShape(ShapeId.from("smithy.api#Boolean"))); + assertEquals("Dafny.ISequence", nameResolver.dafnyTypeForShape(ShapeId.from("smithy.api#String"))); + assertEquals("int", nameResolver.dafnyTypeForShape(ShapeId.from("smithy.api#Integer"))); + assertEquals("long", nameResolver.dafnyTypeForShape(ShapeId.from("smithy.api#Long"))); + } + + @Test + public void testDafnyTypeForEnum() { + final EnumTrait enumTrait = EnumTrait.builder() + .addEnum(EnumDefinition.builder().value("value").build()) + .build(); + final StringShape enumStringShape = StringShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "EnumString")) + .addTrait(enumTrait) + .build(); + final DotNetNameResolver nameResolver = setupNameResolver( + (builder, modelAssembler) -> modelAssembler.addShape(enumStringShape)); + assertEquals("Dafny.Test.Foobar.EnumString", nameResolver.dafnyTypeForShape(enumStringShape.getId())); + } + + @Test + public void testDafnyTypeForUtf8Bytes() { + final StringShape stringShape = StringShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "Utf8BytesString")) + .addTrait(new DafnyUtf8BytesTrait()) + .build(); + final DotNetNameResolver nameResolver = setupNameResolver( + (builder, modelAssembler) -> modelAssembler.addShape(stringShape)); + assertEquals("Dafny.ISequence", nameResolver.dafnyTypeForShape(stringShape.getId())); + } + + @Test + public void testDafnyTypeForAggregateTypes() { + final ShapeId listShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "BoolList"); + final ListShape listShape = ListShape.builder() + .id(listShapeId) + .member(ShapeId.from("smithy.api#Boolean")) + .build(); + final MapShape mapShape = MapShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "StringToBoolListMap")) + .key(ShapeId.from("smithy.api#String")) + .value(listShapeId) + .build(); + final DotNetNameResolver nameResolver = setupNameResolver(((builder, modelAssembler) -> { + modelAssembler.addShape(listShape); + modelAssembler.addShape(mapShape); + })); + assertEquals("Dafny.ISequence", nameResolver.dafnyTypeForShape(listShape.getId())); + assertEquals("Dafny.IMap, Dafny.ISequence>", + nameResolver.dafnyTypeForShape(mapShape.getId())); + } + + @Test + public void testDafnyTypeForStructure() { + final StructureShape foobarStructureShape = TestModel.setupFoobarStructureShape(); + final DotNetNameResolver nameResolver = setupNameResolver( + (builder, modelAssembler) -> modelAssembler.addShape(foobarStructureShape)); + assertEquals("Dafny.Test.Foobar.Foobar", nameResolver.dafnyTypeForShape(foobarStructureShape.getId())); + } + + @Test + public void testDafnyTypeForReferenceStructure() { + final ReferenceTrait referenceTrait = ReferenceTrait.builder() + .referentType(ReferenceTrait.ReferentType.SERVICE) + .referentId(SERVICE_SHAPE_ID) + .build(); + final StructureShape referenceShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "ServiceReference")) + .addTrait(referenceTrait) + .build(); + final DotNetNameResolver nameResolver = setupNameResolver( + (builder, modelAssembler) -> modelAssembler.addShape(referenceShape)); + assertEquals("Dafny.Test.Foobar.IFoobarServiceClient", nameResolver.dafnyTypeForShape(referenceShape.getId())); + } + + @Test + public void testDafnyTypeForPositionalStructure() { + final PositionalTrait positionalTrait = PositionalTrait.builder().build(); + final StructureShape positionalShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "PositionalShape")) + .addMember("aBoolean", ShapeId.from("smithy.api#Boolean")) + .addTrait(positionalTrait) + .build(); + final DotNetNameResolver nameResolver = setupNameResolver( + (builder, modelAssembler) -> modelAssembler.addShape(positionalShape)); + assertEquals("bool", nameResolver.dafnyTypeForShape(positionalShape.getId())); + } + + @Test + public void testDafnyTypeForMember() { + final StructureShape foobarStructureShape = TestModel.setupFoobarStructureShape(); + final DotNetNameResolver nameResolver = setupNameResolver( + (builder, modelAssembler) -> modelAssembler.addShape(foobarStructureShape)); + assertEquals("Wrappers_Compile.Option", + nameResolver.dafnyTypeForShape(ShapeId.fromParts(SERVICE_NAMESPACE, "Foobar", "someInt"))); + assertEquals("Wrappers_Compile.Option>", + nameResolver.dafnyTypeForShape(ShapeId.fromParts(SERVICE_NAMESPACE, "Foobar", "someString"))); + assertEquals("bool", + nameResolver.dafnyTypeForShape(ShapeId.fromParts(SERVICE_NAMESPACE, "Foobar", "someBool"))); + } + + @Test + public void testDafnyImplForServiceClient() { + final DotNetNameResolver nameResolver = setupNameResolver((_builder, _modelAssembler) -> {}); + final String actualName = nameResolver.dafnyImplForServiceClient(); + final String expectedName = "Dafny.Test.Foobar.FoobarServiceClient.FoobarServiceClient"; + assertEquals(expectedName, actualName); + } +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/ServiceCodegenSmokeTest.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/ServiceCodegenSmokeTest.java new file mode 100644 index 0000000000..51ecdad328 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/ServiceCodegenSmokeTest.java @@ -0,0 +1,49 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import org.junit.Test; +import software.amazon.polymorph.utils.ModelUtils; +import software.amazon.polymorph.utils.TokenTree; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.loader.ModelAssembler; +import software.amazon.smithy.model.shapes.ShapeId; + +import java.net.URL; +import java.nio.file.Path; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.junit.Assert.*; + +public class ServiceCodegenSmokeTest { + @Test + public void testCorrectFilesGenerated() { + final URL modelUrl = Objects.requireNonNull(this.getClass().getClassLoader().getResource("model.smithy")); + final ModelAssembler assembler = new ModelAssembler(); + ModelUtils.addCustomTraitsToModelAssembler(assembler); + final Model model = assembler.addImport(modelUrl).assemble().unwrap(); + + final ShapeId serviceShapeId = ShapeId.fromParts("polymorph.demo", "StringLists"); + final ServiceCodegen serviceCodegen = new ServiceCodegen(model, serviceShapeId); + final Map codeByPath = serviceCodegen.generate(); + + final Set expectedPaths = Stream.of( + "IStringLists", + "StringListsClientBase", + "CreateArrayListInput", + "CreateArrayListOutput", + "IListOfStrings", + "ListOfStringsBase", + "GetElementInput", + "GetElementOutput", + "SetElementInput", + "IndexOutOfBoundsException" + ).map(name -> Path.of(name + ".cs")).collect(Collectors.toSet()); + assertEquals(expectedPaths, codeByPath.keySet()); + } +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/ServiceCodegenTest.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/ServiceCodegenTest.java new file mode 100644 index 0000000000..532ba172f6 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/ServiceCodegenTest.java @@ -0,0 +1,659 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import org.junit.Test; +import software.amazon.polymorph.traits.ClientConfigTrait; +import software.amazon.polymorph.traits.PositionalTrait; +import software.amazon.polymorph.traits.ReferenceTrait; +import software.amazon.polymorph.util.TestModel; +import software.amazon.polymorph.util.Tokenizer; +import software.amazon.polymorph.util.Tokenizer.ParseToken; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ResourceShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StringShape; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.EnumDefinition; +import software.amazon.smithy.model.traits.EnumTrait; +import software.amazon.smithy.model.traits.TraitDefinition; + +import java.nio.file.Path; +import java.util.List; +import java.util.Objects; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static software.amazon.polymorph.util.TestModel.SERVICE_NAMESPACE; +import static software.amazon.polymorph.util.TestModel.SERVICE_SHAPE_ID; + +public class ServiceCodegenTest { + @Test + public void testGenerateEmptyService() { + final Model model = TestModel.setupModel(); + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final Path expectedPath = Path.of("IFoobarService.cs"); + final String actualCode = Objects.requireNonNull(codegen.generate().get(expectedPath)).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + public interface IFoobarService { + } + } + """); + + // Ignore the prelude + final List lastActualTokens = actualTokens.subList( + actualTokens.size() - expectedTokens.size(), actualTokens.size()); + assertEquals(expectedTokens, lastActualTokens); + } + + @Test + public void testGenerateServiceClientBaseWithoutClientConfig() { + final StructureShape inputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingInput")) + .build(); + final StructureShape outputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingOutput")) + .build(); + final OperationShape operationShape = OperationShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomething")) + .input(inputShape.getId()) + .output(outputShape.getId()) + .build(); + final Model model = TestModel.setupModel((builder, modelAssembler) -> { + modelAssembler.addShape(inputShape); + modelAssembler.addShape(outputShape); + builder.addOperation(operationShape.getId()); + modelAssembler.addShape(operationShape); + }); + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final ServiceShape serviceShape = model.expectShape(SERVICE_SHAPE_ID, ServiceShape.class); + final String actualCode = codegen.generateServiceClientBase(serviceShape).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + public abstract class FoobarServiceClientBase : IFoobarService { + protected FoobarServiceClientBase() {} + + public Test.Foobar.DoSomethingOutput DoSomething(Test.Foobar.DoSomethingInput input) { + input.Validate(); + return _DoSomething(input); + } + protected abstract Test.Foobar.DoSomethingOutput _DoSomething( + Test.Foobar.DoSomethingInput input); + } + } + """); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateServiceClientBaseWithClientConfig() { + final StructureShape configShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "FoobarServiceClientConfig")) + .build(); + final ClientConfigTrait configTrait = ClientConfigTrait.builder() + .clientConfigId(configShape.getId()) + .build(); + final StructureShape inputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingInput")) + .build(); + final StructureShape outputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingOutput")) + .build(); + final OperationShape operationShape = OperationShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomething")) + .input(inputShape.getId()) + .output(outputShape.getId()) + .build(); + final Model model = TestModel.setupModel((builder, modelAssembler) -> { + modelAssembler.addShape(configShape); + modelAssembler.addShape(inputShape); + modelAssembler.addShape(outputShape); + builder.addOperation(operationShape.getId()); + modelAssembler.addShape(operationShape); + modelAssembler.addTrait(SERVICE_SHAPE_ID, configTrait); + }); + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final ServiceShape serviceShape = model.expectShape(SERVICE_SHAPE_ID, ServiceShape.class); + final String actualCode = codegen.generateServiceClientBase(serviceShape).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + public abstract class FoobarServiceClientBase : IFoobarService { + public Test.Foobar.FoobarServiceClientConfig Config { get ; private set; } + + protected FoobarServiceClientBase(Test.Foobar.FoobarServiceClientConfig Config) { + this.Config = Config; + } + + public Test.Foobar.DoSomethingOutput DoSomething(Test.Foobar.DoSomethingInput input) { + input.Validate(); + return _DoSomething(input); + } + protected abstract Test.Foobar.DoSomethingOutput _DoSomething( + Test.Foobar.DoSomethingInput input); + } + } + """); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateServiceInterfaceMethod() { + final StructureShape inputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingInput")) + .build(); + final StructureShape outputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingOutput")) + .build(); + final OperationShape operationShape = OperationShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomething")) + .input(inputShape.getId()) + .output(outputShape.getId()) + .build(); + final Model model = TestModel.setupModel((builder, modelAssembler) -> { + modelAssembler.addShape(inputShape); + modelAssembler.addShape(outputShape); + builder.addOperation(operationShape.getId()); + modelAssembler.addShape(operationShape); + }); + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final String actualCode = codegen.generateInterfaceMethod(operationShape.getId()).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + Test.Foobar.DoSomethingOutput DoSomething(Test.Foobar.DoSomethingInput input); + """); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateServiceInterface() { + final StructureShape inputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingInput")) + .build(); + final StructureShape outputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingOutput")) + .build(); + final OperationShape operationShape = OperationShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomething")) + .input(inputShape.getId()) + .output(outputShape.getId()) + .build(); + final StructureShape inputShape2 = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingInput2")) + .build(); + final StructureShape outputShape2 = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingOutput2")) + .build(); + final OperationShape operationShape2 = OperationShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomething2")) + .input(inputShape2.getId()) + .output(outputShape2.getId()) + .build(); + final Model model = TestModel.setupModel((builder, modelAssembler) -> { + modelAssembler.addShape(inputShape); + modelAssembler.addShape(outputShape); + builder.addOperation(operationShape.getId()); + modelAssembler.addShape(operationShape); + + modelAssembler.addShape(inputShape2); + modelAssembler.addShape(outputShape2); + builder.addOperation(operationShape2.getId()); + modelAssembler.addShape(operationShape2); + }); + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final String actualCode = codegen.generateServiceInterface().toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + public interface IFoobarService { + Test.Foobar.DoSomethingOutput DoSomething (Test.Foobar.DoSomethingInput input); + Test.Foobar.DoSomethingOutput2 DoSomething2(Test.Foobar.DoSomethingInput2 input); + } + } + """); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateStructureClass() { + final Model model = TestModel.setupModel((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + structure Foobar { + SomeBool: Boolean, + @required + SomeInt: Integer, + SomeString: String, + } + """.formatted(SERVICE_NAMESPACE))); + + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Foobar"); + final StructureShape structureShape = model.expectShape(shapeId, StructureShape.class); + final String actualCode = codegen.generateStructureClass(structureShape).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + public class Foobar { + private bool? _someBool; + private int? _someInt; + private string _someString; + + public bool SomeBool { + get { return this._someBool.GetValueOrDefault(); } + set { this._someBool = value; } + } + public int SomeInt { + get { return this._someInt.GetValueOrDefault(); } + set { this._someInt = value; } + } + public string SomeString { + get { return this._someString; } + set { this._someString = value; } + } + + public void Validate() { + } + } + } + """); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateResourceInterface() { + // Input, no output + final StructureShape inputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingInput")) + .build(); + final OperationShape operationInputShape = OperationShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingWithInput")) + .input(inputShape.getId()) + .build(); + + // Output, no input + final StructureShape outputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingOutput")) + .build(); + final OperationShape operationOutputShape = OperationShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingWithOutput")) + .output(outputShape.getId()) + .build(); + + final ResourceShape resourceShape = ResourceShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "Baz")) + .addOperation(operationInputShape) + .addOperation(operationOutputShape) + .build(); + + final Model model = TestModel.setupModel((builder, modelAssembler) -> { + modelAssembler.addShape(inputShape); + modelAssembler.addShape(outputShape); + modelAssembler.addShape(operationInputShape); + modelAssembler.addShape(operationOutputShape); + modelAssembler.addShape(resourceShape); + }); + + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final String actualCode = codegen.generateResourceInterface(resourceShape.getId()).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + public interface IBaz { + void DoSomethingWithInput(Test.Foobar.DoSomethingInput input); + Test.Foobar.DoSomethingOutput DoSomethingWithOutput(); + } + } + """); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateResourceClass() { + // Input, no output + final StructureShape inputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingInput")) + .build(); + final OperationShape operationInputShape = OperationShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingWithInput")) + .input(inputShape.getId()) + .build(); + + // Output, no input + final StructureShape outputShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingOutput")) + .build(); + final OperationShape operationOutputShape = OperationShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingWithOutput")) + .output(outputShape.getId()) + .build(); + + final ResourceShape resourceShape = ResourceShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "Baz")) + .addOperation(operationInputShape) + .addOperation(operationOutputShape) + .build(); + + final Model model = TestModel.setupModel((builder, modelAssembler) -> { + modelAssembler.addShape(inputShape); + modelAssembler.addShape(outputShape); + modelAssembler.addShape(operationInputShape); + modelAssembler.addShape(operationOutputShape); + modelAssembler.addShape(resourceShape); + }); + + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final String actualCode = codegen.generateResourceClass(resourceShape.getId()).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + public abstract class BazBase : IBaz { + public void DoSomethingWithInput(Test.Foobar.DoSomethingInput input) { + input.Validate(); + _DoSomethingWithInput(input); + } + protected abstract void _DoSomethingWithInput(Test.Foobar.DoSomethingInput input); + + public Test.Foobar.DoSomethingOutput DoSomethingWithOutput() { + return _DoSomethingWithOutput(); + } + protected abstract Test.Foobar.DoSomethingOutput _DoSomethingWithOutput(); + } + } + """); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateResourceClassWithPositionalOutput() { + /* + * Test that shapes marked with @positional are unwrapped to their single member shape rather than the wrapper + * shape. + */ + final StructureShape targetShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "TargetShape")) + .build(); + final StructureShape wrapperShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "WrapperShape")) + .addMember("baz", targetShape.getId()) + .addTrait(PositionalTrait.builder().build()) + .build(); + final OperationShape operationOutputShape = OperationShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingWithOutput")) + .output(wrapperShape.getId()) + .build(); + + final ResourceShape resourceShape = ResourceShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "Baz")) + .addOperation(operationOutputShape) + .build(); + + final Model model = TestModel.setupModel((builder, modelAssembler) -> { + modelAssembler.addShape(targetShape); + modelAssembler.addShape(wrapperShape); + modelAssembler.addShape(operationOutputShape); + modelAssembler.addShape(resourceShape); + }); + + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final String actualCode = codegen.generateResourceClass(resourceShape.getId()).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + public abstract class BazBase : IBaz { + public Test.Foobar.TargetShape DoSomethingWithOutput() { + return _DoSomethingWithOutput(); + } + protected abstract Test.Foobar.TargetShape _DoSomethingWithOutput(); + } + } + """); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testBadPositionalTrait() { + /* + * Test that a shape marked with @positional that has two members throws an exception + */ + final StructureShape targetShape1 = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "TargetShape1")) + .build(); + final StructureShape targetShape2 = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "TargetShape2")) + .build(); + final StructureShape wrapperShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "WrapperShape")) + .addMember("baz", targetShape1.getId()) + .addMember("bar", targetShape2.getId()) + .addTrait(PositionalTrait.builder().build()) + .build(); + final OperationShape operationOutputShape = OperationShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "DoSomethingWithOutput")) + .output(wrapperShape.getId()) + .build(); + + final ResourceShape resourceShape = ResourceShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "Baz")) + .addOperation(operationOutputShape) + .build(); + + final Model model = TestModel.setupModel((builder, modelAssembler) -> { + modelAssembler.addShape(targetShape1); + modelAssembler.addShape(targetShape2); + modelAssembler.addShape(wrapperShape); + modelAssembler.addShape(operationOutputShape); + modelAssembler.addShape(resourceShape); + }); + + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + try { + codegen.generateResourceClass(resourceShape.getId()).toString(); + } catch (IllegalStateException e) { + assertEquals(e.getMessage(), "Structures marked with '@positional' must have exactly one member"); + } + } + + @Test + public void testGenerateStructureWithReference() { + /* + * Tests that structures which contain members which are marked with @reference correctly use the referenced + * service/resource rather than the wrapper. + */ + final Model model = TestModel.setupModel((builder, modelAssembler) -> { + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + use aws.polymorph#reference + resource Dummy {} + @reference(resource: Dummy) structure DummyReference {} + structure Container { dummy: DummyReference } + """.formatted(SERVICE_NAMESPACE)); + }); + + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final ShapeId memberId = ShapeId.fromParts(SERVICE_NAMESPACE, "Container", "dummy"); + final MemberShape memberShape = model.expectShape(memberId, MemberShape.class); + final String actualCode = codegen.generateStructureClassField(memberShape).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + final List expectedTokens = Tokenizer.tokenize("private Test.Foobar.IDummy _dummy;"); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateNamedEnumClass() { + final EnumTrait enumTrait = EnumTrait.builder() + .addEnum(EnumDefinition.builder() + .value("t2.nano") + .name("T2_NANO") + .documentation("t2.nano documentation") + .tags(List.of("ebsOnly")) + .build()) + .addEnum(EnumDefinition.builder() + .value("t2.micro") + .name("T2_MICRO") + .documentation("t2.micro documentation") + .tags(List.of("ebsOnly")) + .build()) + .addEnum(EnumDefinition.builder() + .value("m256.mega") + .name("M256_MEGA") + .deprecated(true) + .build()) + .build(); + final StringShape instanceTypeShape = StringShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "InstanceType")) + .addTrait(enumTrait) + .build(); + final Model model = TestModel.setupModel((builder, modelAssembler) -> modelAssembler.addShape(instanceTypeShape)); + + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final String actualCode = codegen.generateEnumClass(instanceTypeShape.getId()).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + using Amazon.Runtime; + + public class InstanceType : ConstantClass { + /// + /// t2.nano documentation + /// + public static readonly InstanceType T2_NANO = new InstanceType("t2.nano"); + + /// + /// t2.micro documentation + /// + public static readonly InstanceType T2_MICRO = new InstanceType("t2.micro"); + + [System.Obsolete] + public static readonly InstanceType M256_MEGA = new InstanceType("m256.mega"); + + public static readonly InstanceType[] Values = {M256_MEGA, T2_MICRO, T2_NANO}; + + public InstanceType(string value) : base(value) {} + } + } + """); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateUnnamedEnumClass() { + final EnumTrait enumTrait = EnumTrait.builder() + .addEnum(EnumDefinition.builder().value("t2.nano").build()) + .addEnum(EnumDefinition.builder().value("t2.micro").build()) + .build(); + final StringShape instanceTypeShape = StringShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "InstanceType")) + .addTrait(enumTrait) + .build(); + final Model model = TestModel.setupModel((builder, modelAssembler) -> modelAssembler.addShape(instanceTypeShape)); + + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + final String actualCode = codegen.generateEnumClass(instanceTypeShape.getId()).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + public class InstanceType { + public static readonly string[] Values = {"t2.micro", "t2.nano"}; + + public InstanceType(string value) : base(value) {} + } + } + """); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testShouldNotGenerateStructureReference() { + final ReferenceTrait trait = ReferenceTrait.builder() + .referentId(SERVICE_SHAPE_ID) + .referentType(ReferenceTrait.ReferentType.RESOURCE) + .build(); + final StructureShape foobarStructureShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "Foobar")) + .addTrait(trait) + .build(); + + final Model model = TestModel.setupModel((builder, modelAssembler) -> modelAssembler.addShape(foobarStructureShape)); + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + + assertFalse( + "Should not try to generate class for structure marked with @reference", + codegen.shouldGenerateStructure(foobarStructureShape) + ); + } + + @Test + public void testShouldNotGenerateStructurePositional() { + final PositionalTrait trait = PositionalTrait.builder().build(); + final StructureShape foobarStructureShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "Foobar")) + .addTrait(trait) + .build(); + + final Model model = TestModel.setupModel((builder, modelAssembler) -> modelAssembler.addShape(foobarStructureShape)); + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + + assertFalse( + "Should not try to generate class for structure marked with @positional", + codegen.shouldGenerateStructure(foobarStructureShape) + ); + } + + @Test + public void testShouldNotGenerateStructureTrait() { + final TraitDefinition trait = TraitDefinition.builder().build(); + final StructureShape foobarStructureShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "Foobar")) + .addTrait(trait) + .build(); + + final Model model = TestModel.setupModel((builder, modelAssembler) -> modelAssembler.addShape(foobarStructureShape)); + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + + assertFalse( + "Should not try to generate class for structure marked with @trait", + codegen.shouldGenerateStructure(foobarStructureShape) + ); + } + + @Test + public void testShouldGenerateStructureTrue() { + final TraitDefinition trait = TraitDefinition.builder().build(); + final StructureShape foobarStructureShape = StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "Foobar")) + .build(); + + final Model model = TestModel.setupModel((builder, modelAssembler) -> modelAssembler.addShape(foobarStructureShape)); + final ServiceCodegen codegen = new ServiceCodegen(model, SERVICE_SHAPE_ID); + + assertTrue( + "Should have generated class for structure", + codegen.shouldGenerateStructure(foobarStructureShape) + ); + } + +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/ShimCodegenTest.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/ShimCodegenTest.java new file mode 100644 index 0000000000..0b898b25c2 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/ShimCodegenTest.java @@ -0,0 +1,251 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import org.junit.Test; +import software.amazon.polymorph.traits.ClientConfigTrait; +import software.amazon.polymorph.util.TestModel; +import software.amazon.polymorph.util.Tokenizer; +import software.amazon.polymorph.util.Tokenizer.ParseToken; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.loader.ModelAssembler; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StructureShape; + +import java.nio.file.Path; +import java.util.List; +import java.util.Set; +import java.util.function.BiConsumer; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.junit.Assert.*; +import static software.amazon.polymorph.util.TestModel.SERVICE_NAMESPACE; +import static software.amazon.polymorph.util.TestModel.SERVICE_SHAPE_ID; + +public class ShimCodegenTest { + private static ShimCodegen setupCodegen(final BiConsumer updater) { + final Model model = TestModel.setupModel(updater); + return new ShimCodegen(model, SERVICE_SHAPE_ID); + } + + @Test + public void testGenerateAll() { + final ShimCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + resource Thing {} + """.formatted(SERVICE_NAMESPACE))); + + final Set expectedPaths = Stream.of("FoobarServiceClient", "Thing") + .map(name -> Path.of(name + ".cs")).collect(Collectors.toSet()); + final Set actualPaths = codegen.generate().keySet(); + assertEquals(expectedPaths, actualPaths); + } + + @Test + public void testGenerateServiceShim() { + final ShapeId operationShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "DoIt"); + final ShimCodegen codegen = setupCodegen((builder, modelAssembler) -> { + modelAssembler.addShape(OperationShape.builder().id(operationShapeId).build()); + builder.addOperation(operationShapeId); + }); + + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + public class FoobarServiceClient : FoobarServiceClientBase { + private Dafny.Test.Foobar.FoobarServiceClient.FoobarServiceClient _impl; + public FoobarServiceClient() { + this._impl = new Dafny.Test.Foobar.FoobarServiceClient.FoobarServiceClient(); + } + protected override void _DoIt() { this._impl.DoIt(); } + } + } + """); + + final String actualCode = codegen.generateServiceShim().toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateServiceConstructorWithConfig() { + final ShapeId configShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Config"); + final ShimCodegen codegen = setupCodegen((builder, modelAssembler) -> { + modelAssembler.addShape(StructureShape.builder().id(configShapeId).build()); + builder.addTrait(ClientConfigTrait.builder().clientConfigId(configShapeId).build()); + }); + + final List expectedTokens = Tokenizer.tokenize(""" + public FoobarServiceClient(Test.Foobar.Config config) : base(config) { + this._impl = new Dafny.Test.Foobar.FoobarServiceClient.FoobarServiceClient(%s(config)); + } + """.formatted(DotNetNameResolver.qualifiedTypeConverter(configShapeId, TypeConversionDirection.TO_DAFNY))); + + final String actualCode = codegen.generateServiceConstructor().toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateServiceConstructorWithoutConfig() { + final ShimCodegen codegen = setupCodegen((_builder, _modelAssembler) -> {}); + + final List expectedTokens = Tokenizer.tokenize(""" + public FoobarServiceClient() { + this._impl = new Dafny.Test.Foobar.FoobarServiceClient.FoobarServiceClient(); + } + """); + + final String actualCode = codegen.generateServiceConstructor().toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateResourceShim() { + final ShimCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + resource Doer { operations: [DoIt] } + operation DoIt {} + """.formatted(SERVICE_NAMESPACE))); + final ShapeId resourceShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Doer"); + + final List expectedTokens = Tokenizer.tokenize(""" + namespace Test.Foobar { + internal class Doer : DoerBase { + internal Dafny.Test.Foobar.IDoer _impl { get; } + internal Doer(Dafny.Test.Foobar.IDoer impl) { this._impl = impl; } + protected override void _DoIt() { this._impl.DoIt(); } + } + } + """); + + final String actualCode = codegen.generateResourceShim(resourceShapeId).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateResourceConstructor() { + final ShimCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + resource Thing {} + """.formatted(SERVICE_NAMESPACE))); + final ShapeId resourceShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Thing"); + + final List expectedTokens = Tokenizer.tokenize( + "internal Thing(Dafny.Test.Foobar.IThing impl) { this._impl = impl; }"); + + final String actualCode = codegen.generateResourceConstructor(resourceShapeId).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateOperationShims() { + final ShimCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + resource Doer { operations: [DoThis, DoThat] } + operation DoThis {} + operation DoThat {} + """.formatted(SERVICE_NAMESPACE))); + final ShapeId resourceShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Doer"); + + final List expectedTokens = Tokenizer.tokenize(""" + protected override void _DoThis() { this._impl.DoThis(); } + protected override void _DoThat() { this._impl.DoThat(); } + """); + + final String actualCode = codegen.generateOperationShims(resourceShapeId).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateOperationShimInputOnly() { + final ShimCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + operation DoIt { input: Input } + structure Input {} + """.formatted(SERVICE_NAMESPACE))); + final ShapeId operationShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "DoIt"); + final ShapeId inputShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Input"); + + final List expectedTokens = Tokenizer.tokenize(""" + protected override void _DoIt(Test.Foobar.Input input) { + Dafny.Test.Foobar.Input internalInput = %s(input); + this._impl.DoIt(internalInput); + } + """.formatted(DotNetNameResolver.qualifiedTypeConverter(inputShapeId, TypeConversionDirection.TO_DAFNY))); + + final String actualCode = codegen.generateOperationShim(operationShapeId).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateOperationShimOutputOnly() { + final ShimCodegen codegen = setupCodegen((builder, modelAssembler) -> modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + operation DoIt { output: Output } + structure Output {} + """.formatted(SERVICE_NAMESPACE))); + final ShapeId operationShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "DoIt"); + final ShapeId outputShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Output"); + + final List expectedTokens = Tokenizer.tokenize(""" + protected override Test.Foobar.Output _DoIt() { + Dafny.Test.Foobar.Output internalOutput = + this._impl.DoIt(); + return %s(internalOutput); + } + """.formatted(DotNetNameResolver.qualifiedTypeConverter(outputShapeId, TypeConversionDirection.FROM_DAFNY))); + + final String actualCode = codegen.generateOperationShim(operationShapeId).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateOperationShimInputAndOutput() { + final ShimCodegen codegen = setupCodegen((builder, modelAssembler) -> { + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + operation DoIt { input: Input, output: Output } + structure Input {} + structure Output {} + """.formatted(SERVICE_NAMESPACE)); + }); + final ShapeId operationShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "DoIt"); + final ShapeId inputShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Input"); + final ShapeId outputShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Output"); + + final List expectedTokens = Tokenizer.tokenize(""" + protected override Test.Foobar.Output _DoIt(Test.Foobar.Input input) { + Dafny.Test.Foobar.Input internalInput = %s(input); + Dafny.Test.Foobar.Output internalOutput = + this._impl.DoIt(internalInput); + return %s(internalOutput); + } + """.formatted( + DotNetNameResolver.qualifiedTypeConverter(inputShapeId, TypeConversionDirection.TO_DAFNY), + DotNetNameResolver.qualifiedTypeConverter(outputShapeId, TypeConversionDirection.FROM_DAFNY))); + + final String actualCode = codegen.generateOperationShim(operationShapeId).toString(); + final List actualTokens = Tokenizer.tokenize(actualCode); + + assertEquals(expectedTokens, actualTokens); + } +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/TypeConversionCodegenTest.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/TypeConversionCodegenTest.java new file mode 100644 index 0000000000..76a2845fb3 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/smithydotnet/TypeConversionCodegenTest.java @@ -0,0 +1,674 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.smithydotnet; + +import org.junit.Test; +import software.amazon.polymorph.smithydotnet.TypeConversionCodegen.TypeConverter; +import software.amazon.polymorph.traits.ClientConfigTrait; +import software.amazon.polymorph.antlr.CSharpLexer; +import software.amazon.polymorph.util.TestModel; +import software.amazon.polymorph.util.Tokenizer; +import software.amazon.polymorph.util.Tokenizer.ParseToken; +import software.amazon.polymorph.utils.TokenTree; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.loader.ModelAssembler; +import software.amazon.smithy.model.shapes.BlobShape; +import software.amazon.smithy.model.shapes.BooleanShape; +import software.amazon.smithy.model.shapes.IntegerShape; +import software.amazon.smithy.model.shapes.ListShape; +import software.amazon.smithy.model.shapes.LongShape; +import software.amazon.smithy.model.shapes.MapShape; +import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StringShape; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.shapes.TimestampShape; + +import java.nio.file.Path; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.function.BiConsumer; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.junit.Assert.*; +import static software.amazon.polymorph.smithydotnet.TypeConversionCodegen.TYPE_CONVERSION_CLASS_PATH; +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.FROM_DAFNY; +import static software.amazon.polymorph.smithydotnet.TypeConversionDirection.TO_DAFNY; +import static software.amazon.polymorph.util.TestModel.SERVICE_NAMESPACE; +import static software.amazon.polymorph.util.TestModel.SERVICE_SHAPE_ID; + +public class TypeConversionCodegenTest { + private static TypeConversionCodegen setupCodegen(final BiConsumer updater) { + final Model model = TestModel.setupModel(updater); + return new TypeConversionCodegen(model, SERVICE_SHAPE_ID); + } + + private static List generateAndTokenize(final TypeConversionCodegen codegen) { + final Map generatedCode = codegen.generate(); + assertTrue(generatedCode.containsKey(TYPE_CONVERSION_CLASS_PATH)); + final String actualCode = Objects.requireNonNull(generatedCode.get(TYPE_CONVERSION_CLASS_PATH)).toString(); + return Tokenizer.tokenize(actualCode); + } + + @Test + public void testGenerateEmptyModel() { + final TypeConversionCodegen codegen = setupCodegen((_builder, _modelAssembler) -> {}); + final List actualTokens = generateAndTokenize(codegen); + final List expectedTokens = Tokenizer.tokenize(""" + using System.Linq; + using Aws.Crypto; + namespace Test.Foobar { + internal static class TypeConversion {} + } + """); + assertEquals(expectedTokens, actualTokens); + } + + @Test + public void testGenerateSimpleModel() { + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> { + builder.addOperation(ShapeId.fromParts(SERVICE_NAMESPACE, "DoBar")); + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + operation DoBar { input: DoBarInput, output: DoBarOutput } + structure DoBarInput { bool: Boolean } + structure DoBarOutput { int: Integer } + """.formatted(SERVICE_NAMESPACE)); + }); + final Set actualTokens = new HashSet<>(generateAndTokenize(codegen)); + + final Stream expectedConverterMethods = Stream.of( + SERVICE_NAMESPACE + "#DoBarInput", + SERVICE_NAMESPACE + "#DoBarInput$bool", + SERVICE_NAMESPACE + "#DoBarOutput", + SERVICE_NAMESPACE + "#DoBarOutput$int", + "smithy.api#Boolean", + "smithy.api#Integer" + ) + .map(ShapeId::from) + .flatMap(shapeId -> Stream.of( + DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY), + DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY) + )) + .map(converterName -> new ParseToken(converterName, CSharpLexer.IDENTIFIER)); + assertTrue(expectedConverterMethods.allMatch(actualTokens::contains)); + } + + @Test + public void testFindShapeIdsToConvert() { + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> { + builder.addOperation(ShapeId.fromParts(SERVICE_NAMESPACE, "DoBar")); + builder.addTrait(ClientConfigTrait.builder() + .clientConfigId(ShapeId.fromParts(SERVICE_NAMESPACE, "FoobarConfig")) + .build()); + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + structure FoobarConfig {} + resource FooResource { operations: [DoBaz] } + operation DoBar { input: DoBarInput } + operation DoBaz { output: DoBazOutput } + structure DoBarInput { qux: Qux } + structure DoBazOutput { xyzzy: Xyzzy } + map Qux { key: String, value: Integer } + list Xyzzy { member: Blob } + """.formatted(SERVICE_NAMESPACE)); + }); + final Set expectedShapeIds = Stream.of( + SERVICE_NAMESPACE + "#FoobarConfig", + SERVICE_NAMESPACE + "#DoBarInput", + SERVICE_NAMESPACE + "#DoBarInput$qux", + SERVICE_NAMESPACE + "#DoBazOutput", + SERVICE_NAMESPACE + "#DoBazOutput$xyzzy", + SERVICE_NAMESPACE + "#Qux", + SERVICE_NAMESPACE + "#Qux$key", + SERVICE_NAMESPACE + "#Qux$value", + SERVICE_NAMESPACE + "#Xyzzy", + SERVICE_NAMESPACE + "#Xyzzy$member", + "smithy.api#String", + "smithy.api#Integer", + "smithy.api#Blob" + ).map(ShapeId::from).collect(Collectors.toSet()); + + final Set actualShapeIds = codegen.findShapeIdsToConvert(); + assertEquals(expectedShapeIds, actualShapeIds); + } + + @Test + public void testGenerateBlobConverter() { + final ShapeId shapeId = ShapeId.from("smithy.api#Blob"); + final TypeConversionCodegen codegen = setupCodegen((_builder, _modelAssembler) -> {}); + final TypeConverter converter = codegen.generateBlobConverter(BlobShape.builder().id(shapeId).build()); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String fromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static System.IO.MemoryStream %s(Dafny.ISequence value) { + return new System.IO.MemoryStream(value.Elements); + } + """.formatted(fromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String toDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.ISequence %s(System.IO.MemoryStream value) { + return Dafny.Sequence.FromArray(value.ToArray()); + } + """.formatted(toDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateBooleanConverter() { + final ShapeId shapeId = ShapeId.from("smithy.api#Boolean"); + final TypeConversionCodegen codegen = setupCodegen((_builder, _modelAssembler) -> {}); + final TypeConverter converter = codegen.generateBooleanConverter(BooleanShape.builder().id(shapeId).build()); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String fromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize( + "public static bool %s(bool value) { return value; }".formatted(fromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String toDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize( + "public static bool %s(bool value) { return value; }".formatted(toDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateStringConverterRegularString() { + final ShapeId shapeId = ShapeId.from("smithy.api#String"); + final TypeConversionCodegen codegen = setupCodegen((_builder, _modelAssembler) -> {}); + final TypeConverter converter = codegen.generateStringConverter(StringShape.builder().id(shapeId).build()); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String fromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static string %s(Dafny.ISequence value) { + return new string(value.Elements); + }""".formatted(fromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String toDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.ISequence %s(string value) { + return Dafny.Sequence.FromString(value); + }""".formatted(toDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateStringConverterEnumString() { + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "AnEnum"); + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + @enum([ + { name: "VERSION_A", value: "bar" }, + { name: "VERSION_B", value: "baz" }, + ]) + string AnEnum + """.formatted(SERVICE_NAMESPACE))); + final TypeConverter converter = codegen.generateStringConverter( + codegen.getModel().expectShape(shapeId, StringShape.class)); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String fromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static Test.Foobar.AnEnum %s(Dafny.Test.Foobar.AnEnum value) { + if (value.is_VERSION__A) return Test.Foobar.AnEnum.VERSION_A; + if (value.is_VERSION__B) return Test.Foobar.AnEnum.VERSION_B; + throw new System.ArgumentException("Invalid Test.Foobar.AnEnum value"); + }""".formatted(fromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String toDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.Test.Foobar.AnEnum %s(Test.Foobar.AnEnum value) { + if (Test.Foobar.AnEnum.VERSION_A.Equals(value)) return Dafny.Test.Foobar.AnEnum.create_VERSION__A(); + if (Test.Foobar.AnEnum.VERSION_B.Equals(value)) return Dafny.Test.Foobar.AnEnum.create_VERSION__B(); + throw new System.ArgumentException("Invalid Test.Foobar.AnEnum value"); + }""".formatted(toDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + /** + * Test that we generate an enum converter correctly when the enum has only one constructor. + * + * This is different than the "normal" case because Dafny doesn't generate a compiled constructor when there's only + * one. + */ + @Test + public void testGenerateStringConverterEnumStringSingleConstructor() { + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "AnEnum"); + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + @enum([{ name: "VERSION_A", value: "bar" }]) + string AnEnum + """.formatted(SERVICE_NAMESPACE))); + final TypeConverter converter = codegen.generateStringConverter( + codegen.getModel().expectShape(shapeId, StringShape.class)); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String fromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static Test.Foobar.AnEnum %s(Dafny.Test.Foobar.AnEnum value) { + if (value.is_VERSION__A) return Test.Foobar.AnEnum.VERSION_A; + throw new System.ArgumentException("Invalid Test.Foobar.AnEnum value"); + }""".formatted(fromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String toDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.Test.Foobar.AnEnum %s(Test.Foobar.AnEnum value) { + if (Test.Foobar.AnEnum.VERSION_A.Equals(value)) return new Dafny.Test.Foobar.AnEnum(); + throw new System.ArgumentException("Invalid Test.Foobar.AnEnum value"); + }""".formatted(toDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateStringConverterUtf8Bytes() { + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Utf8BytesString"); + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + use aws.polymorph#dafnyUtf8Bytes + @dafnyUtf8Bytes + string Utf8BytesString + """.formatted(SERVICE_NAMESPACE))); + final TypeConverter converter = codegen.generateStringConverter( + codegen.getModel().expectShape(shapeId, StringShape.class)); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String fromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static string %s(Dafny.ISequence value) { + System.Text.UTF8Encoding utf8 = new System.Text.UTF8Encoding(false, true); + return utf8.GetString(value.Elements); + }""".formatted(fromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String toDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.ISequence %s(string value) { + System.Text.UTF8Encoding utf8 = new System.Text.UTF8Encoding(false, true); + return Dafny.Sequence.FromArray(utf8.GetBytes(value)); + }""".formatted(toDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateIntegerConverter() { + final ShapeId shapeId = ShapeId.from("smithy.api#Integer"); + final TypeConversionCodegen codegen = setupCodegen((_builder, _modelAssembler) -> {}); + final TypeConverter converter = codegen.generateIntegerConverter(IntegerShape.builder().id(shapeId).build()); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String fromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize( + "public static int %s(int value) { return value; }".formatted(fromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String toDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize( + "public static int %s(int value) { return value; }".formatted(toDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateLongConverter() { + final ShapeId shapeId = ShapeId.from("smithy.api#Long"); + final TypeConversionCodegen codegen = setupCodegen((_builder, _modelAssembler) -> {}); + final TypeConverter converter = codegen.generateLongConverter(LongShape.builder().id(shapeId).build()); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String fromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize( + "public static long %s(long value) { return value; }".formatted(fromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String toDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize( + "public static long %s(long value) { return value; }".formatted(toDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateTimestampConverter() { + final ShapeId shapeId = ShapeId.from("smithy.api#Timestamp"); + final TypeConversionCodegen codegen = setupCodegen((_builder, _modelAssembler) -> {}); + final TypeConverter converter = codegen.generateTimestampConverter( + TimestampShape.builder().id(shapeId).build()); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String fromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static System.DateTime %s(Dafny.ISequence value) { + System.Globalization.CultureInfo culture = new System.Globalization.CultureInfo(""); + string timestampString = new string(value.Elements); + return System.DateTime.ParseExact(timestampString, "s", culture); + } + """.formatted(fromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String toDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.ISequence %s(System.DateTime value) { + System.Globalization.CultureInfo culture = new System.Globalization.CultureInfo(""); + string timestampString = value.ToString("s", culture); + return Dafny.Sequence.FromString(timestampString); + } + """.formatted(toDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateListConverter() { + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "IntList"); + final ShapeId memberShapeId = shapeId.withMember("member"); + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + list IntList { + member: Integer + } + """.formatted(SERVICE_NAMESPACE))); + final TypeConverter converter = codegen.generateListConverter( + codegen.getModel().expectShape(shapeId, ListShape.class)); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String listFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final String intFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static System.Collections.Generic.List %s(Dafny.ISequence value) { + return new System.Collections.Generic.List(value.Elements.Select(%s)); + }""".formatted(listFromDafnyConverterName, intFromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String listToDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final String intToDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.ISequence %s(System.Collections.Generic.List value) { + return Dafny.Sequence.FromArray(value.Select(%s).ToArray()); + }""".formatted(listToDafnyConverterName, intToDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateMapConverter() { + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "BoolMap"); + final ShapeId keyMemberId = shapeId.withMember("key"); + final ShapeId valueMemberId = shapeId.withMember("value"); + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + map BoolMap { + key: String, + value: Boolean, + } + """.formatted(SERVICE_NAMESPACE))); + final TypeConverter converter = codegen.generateMapConverter( + codegen.getModel().expectShape(shapeId, MapShape.class)); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String mapFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final String keyFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(keyMemberId, FROM_DAFNY); + final String valueFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(valueMemberId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static System.Collections.Generic.Dictionary %s( + Dafny.IMap, bool> value) { + return value.ItemEnumerable.ToDictionary(pair => %s(pair.Car), pair => %s(pair.Cdr)); + }""".formatted(mapFromDafnyConverterName, keyFromDafnyConverterName, valueFromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String mapToDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final String keyToDafnyConverterName = DotNetNameResolver.typeConverterForShape(keyMemberId, TO_DAFNY); + final String valueToDafnyConverterName = DotNetNameResolver.typeConverterForShape(valueMemberId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.IMap, bool> %s( + System.Collections.Generic.Dictionary value) { + return Dafny.Map, bool>.FromCollection( + value.Select(pair => + new Dafny.Pair, bool>(%s(pair.Key), %s(pair.Value)) + ) + ); + }""".formatted(mapToDafnyConverterName, keyToDafnyConverterName, valueToDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateStructureConverterRegularStructure() { + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "IntAndBool"); + final ShapeId intMemberId = shapeId.withMember("someInt"); + final ShapeId boolMemberId = shapeId.withMember("someBool"); + final ShapeId stringMemberId = shapeId.withMember("someString"); + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + structure IntAndBool { + someInt: Integer, + @required + someBool: Boolean, + someString: String, + } + """.formatted(SERVICE_NAMESPACE))); + final TypeConverter converter = codegen.generateStructureConverter( + codegen.getModel().expectShape(shapeId, StructureShape.class)); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String structureFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final String intFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(intMemberId, FROM_DAFNY); + final String boolFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(boolMemberId, FROM_DAFNY); + final String stringFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(stringMemberId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static Test.Foobar.IntAndBool %s(Dafny.Test.Foobar.IntAndBool value) { + Test.Foobar.IntAndBool converted = new Test.Foobar.IntAndBool(); + if (value.someInt.is_Some) converted.SomeInt = (int) %s(value.someInt); + converted.SomeBool = (bool) %s(value.someBool); + if (value.someString.is_Some) converted.SomeString = (string) %s(value.someString); + return converted; + }""".formatted( + structureFromDafnyConverterName, + intFromDafnyConverterName, + boolFromDafnyConverterName, + stringFromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String structureToDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final String intToDafnyConverterName = DotNetNameResolver.typeConverterForShape(intMemberId, TO_DAFNY); + final String boolToDafnyConverterName = DotNetNameResolver.typeConverterForShape(boolMemberId, TO_DAFNY); + final String stringToDafnyConverterName = DotNetNameResolver.typeConverterForShape(stringMemberId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.Test.Foobar.IntAndBool %s(Test.Foobar.IntAndBool value) { + return new Dafny.Test.Foobar.IntAndBool( + %s(value.SomeInt), + %s(value.SomeBool), + %s(value.SomeString) + ); + }""".formatted( + structureToDafnyConverterName, + intToDafnyConverterName, + boolToDafnyConverterName, + stringToDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateStructureConverterReferenceStructure() { + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "ThingReference"); + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + use aws.polymorph#reference + resource Thing {} + @reference(resource: Thing) + structure ThingReference {} + """.formatted(SERVICE_NAMESPACE))); + final TypeConverter converter = codegen.generateStructureConverter( + codegen.getModel().expectShape(shapeId, StructureShape.class)); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String structureFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static Test.Foobar.IThing %s(Dafny.Test.Foobar.IThing value) { + return new Thing(value); + }""".formatted(structureFromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String structureToDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.Test.Foobar.IThing %s(Test.Foobar.IThing value) { + if (value is Thing valueWithImpl) { + return valueWithImpl._impl; + } + throw new System.ArgumentException( + "Custom implementations of Test.Foobar.IThing are not supported yet"); + }""".formatted(structureToDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateStructureConverterPositionalStructure() { + final ShapeId shapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "CreateThingOutput"); + final ShapeId memberShapeId = shapeId.withMember("thing"); + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + use aws.polymorph#positional + use aws.polymorph#reference + resource Thing {} + @reference(resource: Thing) + structure ThingReference {} + @positional + structure CreateThingOutput { thing: ThingReference } + """.formatted(SERVICE_NAMESPACE))); + final TypeConverter converter = codegen.generateStructureConverter( + codegen.getModel().expectShape(shapeId, StructureShape.class)); + assertEquals(shapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String structureFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, FROM_DAFNY); + final String memberFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static Test.Foobar.IThing %s(Dafny.Test.Foobar.IThing value) { + return %s(value); + }""".formatted(structureFromDafnyConverterName, memberFromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String structureToDafnyConverterName = DotNetNameResolver.typeConverterForShape(shapeId, TO_DAFNY); + final String memberToDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Dafny.Test.Foobar.IThing %s(Test.Foobar.IThing value) { + return %s(value); + }""".formatted(structureToDafnyConverterName, memberToDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateMemberConverterRequired() { + final ShapeId containerShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Container"); + final ShapeId memberShapeId = containerShapeId.withMember("content"); + final ShapeId targetShapeId = ShapeId.from("smithy.api#Integer"); + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + structure Container { + @required + content: Integer + } + """.formatted(SERVICE_NAMESPACE))); + final TypeConverter converter = codegen.generateMemberConverter( + codegen.getModel().expectShape(memberShapeId, MemberShape.class)); + assertEquals(memberShapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String memberFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShapeId, FROM_DAFNY); + final String targetFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(targetShapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static int %s(int value) { + return %s(value); + }""".formatted(memberFromDafnyConverterName, targetFromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String memberToDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShapeId, TO_DAFNY); + final String targetToDafnyConverterName = DotNetNameResolver.typeConverterForShape(targetShapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static int %s(int value) { + return %s(value); + }""".formatted(memberToDafnyConverterName, targetToDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } + + @Test + public void testGenerateMemberConverterOptional() { + final ShapeId containerShapeId = ShapeId.fromParts(SERVICE_NAMESPACE, "Container"); + final ShapeId memberShapeId = containerShapeId.withMember("content"); + final ShapeId targetShapeId = ShapeId.from("smithy.api#Integer"); + final TypeConversionCodegen codegen = setupCodegen((builder, modelAssembler) -> + modelAssembler.addUnparsedModel("test.smithy", """ + namespace %s + structure Container { + content: Integer + } + """.formatted(SERVICE_NAMESPACE))); + final TypeConverter converter = codegen.generateMemberConverter( + codegen.getModel().expectShape(memberShapeId, MemberShape.class)); + assertEquals(memberShapeId, converter.shapeId()); + + final List actualTokensFromDafny = Tokenizer.tokenize(converter.fromDafny().toString()); + final String memberFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShapeId, FROM_DAFNY); + final String targetFromDafnyConverterName = DotNetNameResolver.typeConverterForShape(targetShapeId, FROM_DAFNY); + final List expectedTokensFromDafny = Tokenizer.tokenize(""" + public static int? %s(Wrappers_Compile.Option value) { + return value.is_None ? (int?) null : %s(value.Extract()); + }""".formatted(memberFromDafnyConverterName, targetFromDafnyConverterName)); + assertEquals(expectedTokensFromDafny, actualTokensFromDafny); + + final List actualTokensToDafny = Tokenizer.tokenize(converter.toDafny().toString()); + final String memberToDafnyConverterName = DotNetNameResolver.typeConverterForShape(memberShapeId, TO_DAFNY); + final String targetToDafnyConverterName = DotNetNameResolver.typeConverterForShape(targetShapeId, TO_DAFNY); + final List expectedTokensToDafny = Tokenizer.tokenize(""" + public static Wrappers_Compile.Option %s(int? value) { + return value == null + ? Wrappers_Compile.Option.create_None() + : Wrappers_Compile.Option.create_Some(%s((int) value)); + }""".formatted(memberToDafnyConverterName, targetToDafnyConverterName)); + assertEquals(expectedTokensToDafny, actualTokensToDafny); + } +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/util/TestModel.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/util/TestModel.java new file mode 100644 index 0000000000..dab19b0166 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/util/TestModel.java @@ -0,0 +1,56 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.util; + +import software.amazon.polymorph.utils.ModelUtils; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.loader.ModelAssembler; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.traits.RequiredTrait; + +import java.util.function.BiConsumer; + +public class TestModel { + public static final String SERVICE_NAMESPACE = "test.foobar"; + public static final String SERVICE_NAME = "FoobarService"; + public static final ShapeId SERVICE_SHAPE_ID = ShapeId.fromParts(SERVICE_NAMESPACE, SERVICE_NAME); + + /** + * Sets up a test model. The updater can modify the {@link ServiceShape.Builder} or the {@link ModelAssembler} + * before either is assembled. The updater is not responsible for adding the ServiceShape to the model assembler; + * this method will do so before returning the assembled model. + */ + public static Model setupModel(final BiConsumer updater) { + final ServiceShape.Builder serviceShapeBuilder = new ServiceShape.Builder() + .version("1.0") + .id(SERVICE_SHAPE_ID); + final ModelAssembler assembler = new ModelAssembler(); + ModelUtils.addCustomTraitsToModelAssembler(assembler); + + updater.accept(serviceShapeBuilder, assembler); + assembler.addShape(serviceShapeBuilder.build()); + return assembler.assemble().unwrap(); + } + + /** + * Sets up a test model containing only the service shape. + */ + public static Model setupModel() { + return setupModel((ServiceShape.Builder _builder, ModelAssembler _assembler) -> {}); + } + + /** + * Sets up a simple "Foobar" structure shape. + */ + public static StructureShape setupFoobarStructureShape() { + return StructureShape.builder() + .id(ShapeId.fromParts(SERVICE_NAMESPACE, "Foobar")) + .addMember("someInt", ShapeId.from("smithy.api#Integer")) + .addMember("someString", ShapeId.from("smithy.api#String")) + .addMember("someBool", ShapeId.from("smithy.api#Boolean"), memberUpdater -> memberUpdater.addTrait(new RequiredTrait())) + .build(); + } +} diff --git a/smithy-dotnet/src/test/java/software/amazon/polymorph/util/Tokenizer.java b/smithy-dotnet/src/test/java/software/amazon/polymorph/util/Tokenizer.java new file mode 100644 index 0000000000..fea3ef8553 --- /dev/null +++ b/smithy-dotnet/src/test/java/software/amazon/polymorph/util/Tokenizer.java @@ -0,0 +1,30 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph.util; + +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.CharStreams; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.Token; +import software.amazon.polymorph.antlr.CSharpLexer; + +import java.util.List; + +/** + * Simple tokenizer for C# source code, intended for testing generated code in a format-agnostic manner. + * Uses the ANTLR-generated parser. + */ +public class Tokenizer { + public static List tokenize(final String source) { + final CharStream charStream = CharStreams.fromString(source); + final Lexer lexer = new CSharpLexer(charStream); + final List lexemes = lexer.getAllTokens(); + return lexemes + .stream() + .filter(lexeme -> lexeme.getType() != CSharpLexer.WHITESPACES) + .map(lexeme -> new ParseToken(lexeme.getText(), lexeme.getType())).toList(); + } + + public static record ParseToken(String text, int type) {} +} diff --git a/smithy-dotnet/src/test/resources/enum.smithy b/smithy-dotnet/src/test/resources/enum.smithy new file mode 100644 index 0000000000..8cb4694f5f --- /dev/null +++ b/smithy-dotnet/src/test/resources/enum.smithy @@ -0,0 +1,33 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +namespace aws.polymorph + +service AwsMaterialProviders { + version: "2021-11-01", + resources: [Keyring], +} + +resource Keyring { + operations: [OnEncrypt] +} + +operation OnEncrypt { + input: OnEncryptInput, + +} +structure OnEncryptInput { + test: AlgorithmSuite +} + +@enum([ + { + name: "ALG_AES_128_GCM_IV12_TAG16_NO_KDF", + value: "0x0014", + }, + { + name: "ALG_AES_192_GCM_IV12_TAG16_NO_KDF", + value: "0x0046", + }, +]) +string AlgorithmSuite diff --git a/smithy-dotnet/src/test/resources/model.smithy b/smithy-dotnet/src/test/resources/model.smithy new file mode 100644 index 0000000000..cf4efa515c --- /dev/null +++ b/smithy-dotnet/src/test/resources/model.smithy @@ -0,0 +1,68 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +$version: "1.0" + +namespace polymorph.demo + +use aws.polymorph#reference + +service StringLists { + version: "2021-06-23", + resources: [ListOfStrings], + operations: [CreateArrayList] +} + +operation CreateArrayList { + input: CreateArrayListInput, + output: CreateArrayListOutput +} +structure CreateArrayListInput { + @documentation("Length of the list to create") + @range(min: 0) + length: Integer +} +structure CreateArrayListOutput { + @required + list: ListOfStringsReference +} + +resource ListOfStrings { + operations: [GetElement, SetElement] +} +@reference(resource: ListOfStrings) +structure ListOfStringsReference {} + +@readonly +operation GetElement { + input: GetElementInput, + output: GetElementOutput, + errors: [IndexOutOfBoundsException] +} +structure GetElementInput { + @range(min: 0) + @required + index: Integer +} +structure GetElementOutput { + @required + value: String +} + +operation SetElement { + input: SetElementInput, + errors: [IndexOutOfBoundsException] +} +structure SetElementInput { + @range(min: 0) + @required + index: Integer, + + @required + value: String +} + +@error("client") +structure IndexOutOfBoundsException { + message: String +} diff --git a/smithy-dotnet/src/test/resources/positional.smithy b/smithy-dotnet/src/test/resources/positional.smithy new file mode 100644 index 0000000000..117a1545ef --- /dev/null +++ b/smithy-dotnet/src/test/resources/positional.smithy @@ -0,0 +1,33 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +namespace aws.polymorph + +service AwsMaterialProviders { + version: "2021-11-01", + resources: [Keyring], + operations: [CreateKeyring] +} + +resource Keyring {} + +@reference(resource: Keyring) +structure KeyringReference {} + +operation CreateKeyring { + output: CreateKeyringOutput +} + +@positional +structure CreateKeyringOutput { + keyring: KeyringReference +} + +@trait(selector: "structure") +structure positional {} + +@trait(selector: "structure") +structure reference { + service: String, + resource: String +} diff --git a/smithy-dotnet/src/test/resources/reference.smithy b/smithy-dotnet/src/test/resources/reference.smithy new file mode 100644 index 0000000000..c91914ace1 --- /dev/null +++ b/smithy-dotnet/src/test/resources/reference.smithy @@ -0,0 +1,30 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +namespace aws.polymorph + +service AwsMaterialProviders { + version: "2021-11-01", + resources: [Keyring], +} + +resource Keyring { + operations: [OnEncrypt] +} + +@reference(resource: Keyring) +structure KeyringReference {} + +operation OnEncrypt { + input: OnEncryptInput, + +} +structure OnEncryptInput { + test: KeyringReference +} + +@trait(selector: "structure") +structure reference { + service: String, + resource: String +} diff --git a/smithy-model-to-idl/.gitignore b/smithy-model-to-idl/.gitignore new file mode 100644 index 0000000000..54caf66065 --- /dev/null +++ b/smithy-model-to-idl/.gitignore @@ -0,0 +1,7 @@ +# Gradle +/.gradle/ +/build/ +/target/ + +# IDE +/.idea/ diff --git a/smithy-model-to-idl/README.md b/smithy-model-to-idl/README.md new file mode 100644 index 0000000000..da287a9da2 --- /dev/null +++ b/smithy-model-to-idl/README.md @@ -0,0 +1,46 @@ +# Smithy model to IDL + +This is a simple wrapper around [Smithy's `SmithyIdlModelSerializer`](https://github.com/awslabs/smithy/blob/main/smithy-model/src/main/java/software/amazon/smithy/model/shapes/SmithyIdlModelSerializer.java), +which allows to serialize a Smithy model (for example, one loaded from a JSON file) into Smithy IDL +in order to improve its legibility. + +## Usage + +Prerequisites: + +- Java 16 or above +- A model you want to serialize at `$MODEL_PATH`, e.g. the [KMS JSON model](https://github.com/aws/aws-models/blob/master/kms/smithy/model.json) +- A clone of the [Smithy repository](https://github.com/awslabs/smithy) at `$SMITHY_REPO_PATH` +- An output directory for the serialized models at `$DEST_PATH` + +```bash +$ # start in project root +$ pwd +~/Polymorph-smithy-dotnet/smithy-model-to-idl + +$ # build +$ ./gradlew build +BUILD SUCCESSFUL in 507ms + +$ # serialize +$ ./gradlew run --args="$DEST_PATH $SMITHY_REPO_PATH $MODEL_PATH" +... +INFO: Wrote /.../com.amazonaws.kms.smithy +... +``` + +If you want to serialize multiple aws models at once, simply append those paths as arguments. +For example: +``` +$ # serialize +$ ./gradlew run --args="$DEST_PATH $SMITHY_REPO_PATH /path/to/aws-models/kms/smithy/model.json /path/to/aws-models/dynamodb/smithy/model.json" +... +INFO: Wrote /.../com.amazonaws.kms.smithy +... +INFO: Wrote /Users/lavaleri/smithy-model-output/com.amazonaws.dynamodb.smithy +... +``` + +You'll find several files in `$DEST_PATH`, +including one for the model you specified (e.g. `$DEST_PATH/com.amazonaws.kms.smithy`) +and others for various namespaces found in the Smithy models. diff --git a/smithy-model-to-idl/build.gradle.kts b/smithy-model-to-idl/build.gradle.kts new file mode 100644 index 0000000000..6e3bc42134 --- /dev/null +++ b/smithy-model-to-idl/build.gradle.kts @@ -0,0 +1,26 @@ +plugins { + java + application +} + +group = "software.amazon.polymorph" +version = "1.0-SNAPSHOT" + +repositories { + mavenCentral() +} + +dependencies { + implementation("software.amazon.smithy:smithy-model:1.10.0") + implementation("software.amazon.smithy:smithy-codegen-core:[1.0.2,1.1.0[") + implementation("software.amazon.smithy:smithy-protocol-test-traits:[1.0.2,1.1.0[") + + implementation("com.google.guava:guava:30.1-jre") + implementation("commons-cli:commons-cli:1.4") + implementation("org.slf4j:slf4j-api:1.7.32") + implementation("org.slf4j:slf4j-simple:1.7.32") +} + +application { + mainClass.set("software.amazon.polymorph.SmithyModelToIdl") +} diff --git a/smithy-model-to-idl/gradle/wrapper/gradle-wrapper.jar b/smithy-model-to-idl/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000..7454180f2a Binary files /dev/null and b/smithy-model-to-idl/gradle/wrapper/gradle-wrapper.jar differ diff --git a/smithy-model-to-idl/gradle/wrapper/gradle-wrapper.properties b/smithy-model-to-idl/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000000..69a9715077 --- /dev/null +++ b/smithy-model-to-idl/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-7.1-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/smithy-model-to-idl/gradlew b/smithy-model-to-idl/gradlew new file mode 100755 index 0000000000..744e882ed5 --- /dev/null +++ b/smithy-model-to-idl/gradlew @@ -0,0 +1,185 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MSYS* | MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=`expr $i + 1` + done + case $i in + 0) set -- ;; + 1) set -- "$args0" ;; + 2) set -- "$args0" "$args1" ;; + 3) set -- "$args0" "$args1" "$args2" ;; + 4) set -- "$args0" "$args1" "$args2" "$args3" ;; + 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=`save "$@"` + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +exec "$JAVACMD" "$@" diff --git a/smithy-model-to-idl/gradlew.bat b/smithy-model-to-idl/gradlew.bat new file mode 100644 index 0000000000..ac1b06f938 --- /dev/null +++ b/smithy-model-to-idl/gradlew.bat @@ -0,0 +1,89 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/smithy-model-to-idl/settings.gradle b/smithy-model-to-idl/settings.gradle new file mode 100644 index 0000000000..21c9a72fc4 --- /dev/null +++ b/smithy-model-to-idl/settings.gradle @@ -0,0 +1,2 @@ +rootProject.name = 'SmithyModelToIdl' + diff --git a/smithy-model-to-idl/src/main/java/software/amazon/polymorph/SmithyModelToIdl.java b/smithy-model-to-idl/src/main/java/software/amazon/polymorph/SmithyModelToIdl.java new file mode 100644 index 0000000000..f9feefcadf --- /dev/null +++ b/smithy-model-to-idl/src/main/java/software/amazon/polymorph/SmithyModelToIdl.java @@ -0,0 +1,71 @@ +// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package software.amazon.polymorph; + +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.loader.ModelAssembler; +import software.amazon.smithy.model.shapes.SmithyIdlModelSerializer; +import software.amazon.smithy.model.traits.DocumentationTrait; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.Collections; +import java.util.Map; +import java.util.Objects; +import java.util.logging.Logger; +import java.util.stream.Stream; + +public class SmithyModelToIdl { + private static final Path PACKAGE_MODEL_RESOURCES_PATH = Path.of("src", "main", "resources", "META-INF", "smithy"); + + public static void main(String[] args) { + final Logger logger = Logger.getLogger(SmithyModelToIdl.class.getSimpleName()); + + if (args.length < 3) { + throw new IllegalStateException("usage: SmithyModelToIdl DEST_PATH SMITHY_REPO_PATH MODEL_PATH..."); + } + + final Path destPath = Path.of(args[0]); + final Path smithyRepoPath = Path.of(args[1]); + + final ModelAssembler modelAssembler = new ModelAssembler(); + + for (int i = 2; i < args.length; i++) { + final Path modelPath = Path.of(args[i]); + modelAssembler.addImport(modelPath); + } + + final File[] smithyRepoPackages = smithyRepoPath.toFile().listFiles(); + if (smithyRepoPackages == null) { + throw new IllegalStateException("no Smithy repo packages found"); + } + Arrays.stream(smithyRepoPackages) + .map(pkg -> pkg.toPath().resolve(PACKAGE_MODEL_RESOURCES_PATH).toFile()) + .map(dir -> dir.listFiles((_dir, name) -> name.endsWith(".smithy") || name.endsWith(".json"))) + .filter(Objects::nonNull) + .flatMap(Stream::of) + .map(File::toPath) + .forEach(modelAssembler::addImport); + + final Model model = modelAssembler.assemble().unwrap(); + + final var serializer = SmithyIdlModelSerializer.builder() + .basePath(destPath) + // Omit documentation since it's visually distracting + .traitFilter(trait -> !(trait instanceof DocumentationTrait)) + .build(); + final Map serializedFiles = serializer.serialize(model); + serializedFiles.forEach((path, code) -> { + try { + Files.write(path, Collections.singleton(code)); + logger.info("Wrote " + path.toAbsolutePath()); + } catch (IOException e) { + e.printStackTrace(); + } + }); + } +}