diff --git a/Runtime.Standard/Runtime.Standard.csproj b/Runtime.Standard/Runtime.Standard.csproj index 6805722..837e2ac 100644 --- a/Runtime.Standard/Runtime.Standard.csproj +++ b/Runtime.Standard/Runtime.Standard.csproj @@ -28,7 +28,7 @@ runtime - + all runtime; build; native; contentfiles; analyzers; buildtransitive diff --git a/Runtime/Runtime.csproj b/Runtime/Runtime.csproj index b75d72b..99caf60 100644 --- a/Runtime/Runtime.csproj +++ b/Runtime/Runtime.csproj @@ -30,7 +30,7 @@ runtime - + all runtime; build; native; contentfiles; analyzers; buildtransitive @@ -50,6 +50,9 @@ + + ..\..\rubberduck-vba\Rubberduck\Rubberduck.Parsing\bin\Debug\net46\Rubberduck.Parsing.dll + diff --git a/Shared/Models/VisualizerData.cs b/Shared/Models/VisualizerData.cs index 409a415..87ba085 100644 --- a/Shared/Models/VisualizerData.cs +++ b/Shared/Models/VisualizerData.cs @@ -33,8 +33,8 @@ public VisualizerData(object o, Config config) { Config = config; Type[] types; - T createInstance(string typename, object[]? args = null) => - (T)Activator.CreateInstance(types.Single(x => x.FullName == typename), args); + T createInstance(string typename, object[]? args = null) => + types.Single(x => x.FullName == typename).CreateInstance(args); { var baseTypes = new[] { typeof(Parser), typeof(Lexer) }; diff --git a/Shared/Util/Extensions/IEnumerableTuple.cs b/Shared/Util/Extensions/IEnumerableTuple.cs index 38ac753..fe93574 100644 --- a/Shared/Util/Extensions/IEnumerableTuple.cs +++ b/Shared/Util/Extensions/IEnumerableTuple.cs @@ -12,5 +12,12 @@ public static string Joined(this IEnumerable<(T1, T2)> src, string delim public static Dictionary ToDictionary(this IEnumerable<(TKey, TValue)> src) => src.ToDictionary(t => t.Item1, t => t.Item2); public static void Add(this List<(T1, T2)> lst, T1 item1, T2 item2) => lst.Add((item1, item2)); + + public static IEnumerable SelectT(this IEnumerable<(T1, T2)> src, Func selector) => + src.Select(x => selector(x.Item1, x.Item2)); + public static IEnumerable SelectT(this IEnumerable<(T1, T2, T3)> src, Func selector) => + src.Select(x => selector(x.Item1, x.Item2)); + public static IEnumerable SelectT(this IEnumerable<(T1, T2, T3, T4)> src, Func selector) => + src.Select(x => selector(x.Item1, x.Item2, x.Item3, x.Item4)); } } diff --git a/Shared/Util/Extensions/Type.cs b/Shared/Util/Extensions/Type.cs index 8631716..3f4faf9 100644 --- a/Shared/Util/Extensions/Type.cs +++ b/Shared/Util/Extensions/Type.cs @@ -66,7 +66,7 @@ public static bool IsAnonymous(this Type type) => }; public static string FriendlyName(this Type type) { - if (type.IsClosureClass()) { return "" ; } + if (type.IsClosureClass()) { return ""; } if (type.IsAnonymous()) { return "{ " + type.GetProperties().Joined(", ", p => { @@ -131,5 +131,6 @@ public static bool IsTupleType(this Type type) { public static bool InheritsFromOrImplementsAny(this Type type, IEnumerable types) => types.Any(t => t.IsAssignableFrom(type)); public static bool InheritsFromOrImplementsAny(this Type type, params Type[] types) => types.Any(t => t.IsAssignableFrom(type)); + public static T CreateInstance(this Type type, object[]? args = null) => (T)Activator.CreateInstance(type, args); } } diff --git a/Tests.Framework/TestClass.cs b/Tests.Framework/TestClass.cs deleted file mode 100644 index 37d9ff9..0000000 --- a/Tests.Framework/TestClass.cs +++ /dev/null @@ -1,13 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -using Xunit; - -namespace Tests.Framework { - public class TestClass { - [Fact] - public void TestMethod() => Assert.True(true); - } -} diff --git a/Tests.Framework/Tests.Framework.csproj b/Tests.Framework/Tests.Framework.csproj deleted file mode 100644 index 53b11f9..0000000 --- a/Tests.Framework/Tests.Framework.csproj +++ /dev/null @@ -1,15 +0,0 @@ - - - - net472 - - - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - diff --git a/Tests.Runtime.Standard/FormatterTest.java b/Tests.Runtime.Standard/FormatterTest.java new file mode 100644 index 0000000..464d4d3 --- /dev/null +++ b/Tests.Runtime.Standard/FormatterTest.java @@ -0,0 +1,4262 @@ +/* Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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. + */ +package tests.api.java.util; + +import java.io.BufferedOutputStream; +import java.io.Closeable; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.FilePermission; +import java.io.Flushable; +import java.io.IOException; +import java.io.OutputStream; +import java.io.PipedOutputStream; +import java.io.PrintStream; +import java.io.UnsupportedEncodingException; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.nio.charset.Charset; +import java.security.Permission; +import java.util.Arrays; +import java.util.Calendar; +import java.util.Date; +import java.util.DuplicateFormatFlagsException; +import java.util.FormatFlagsConversionMismatchException; +import java.util.Formattable; +import java.util.FormattableFlags; +import java.util.Formatter; +import java.util.FormatterClosedException; +import java.util.IllegalFormatCodePointException; +import java.util.IllegalFormatConversionException; +import java.util.IllegalFormatException; +import java.util.IllegalFormatFlagsException; +import java.util.IllegalFormatPrecisionException; +import java.util.IllegalFormatWidthException; +import java.util.Locale; +import java.util.MissingFormatArgumentException; +import java.util.MissingFormatWidthException; +import java.util.TimeZone; +import java.util.UnknownFormatConversionException; + +import junit.framework.TestCase; + +public class FormatterTest extends TestCase { + + class MockAppendable implements Appendable { + public Appendable append(CharSequence arg0) throws IOException { + return null; + } + + public Appendable append(char arg0) throws IOException { + return null; + } + + public Appendable append(CharSequence arg0, int arg1, int arg2) + throws IOException { + return null; + } + } + + class MockSecurityManager extends SecurityManager { + public void checkPermission(Permission p) { + if (p.getActions().equals("write") && p instanceof FilePermission) { + throw new SecurityException("Always throw security exception"); + } + } + + public void checkPermission(Permission p, Object ctx) { + checkPermission(p); + } + } + + class MockFormattable implements Formattable { + public void formatTo(Formatter formatter, int flags, int width, + int precision) throws IllegalFormatException { + if ((flags & FormattableFlags.UPPERCASE) != 0) { + formatter.format("CUSTOMIZED FORMAT FUNCTION" + " WIDTH: " + + width + " PRECISION: " + precision); + } else { + formatter.format("customized format function" + " width: " + + width + " precision: " + precision); + } + } + + public String toString() { + return "formattable object"; + } + + public int hashCode() { + return 0xf; + } + } + + class MockDestination implements Appendable, Flushable { + + private StringBuilder data = new StringBuilder(); + + private boolean enabled = false; + + public Appendable append(char c) throws IOException { + if (enabled) { + data.append(c); + enabled = true; // enable it after the first append + } else { + throw new IOException(); + } + return this; + } + + public Appendable append(CharSequence csq) throws IOException { + if (enabled) { + data.append(csq); + enabled = true; // enable it after the first append + } else { + throw new IOException(); + } + return this; + } + + public Appendable append(CharSequence csq, int start, int end) + throws IOException { + if (enabled) { + data.append(csq, start, end); + enabled = true; // enable it after the first append + } else { + throw new IOException(); + } + return this; + } + + public void flush() throws IOException { + throw new IOException("Always throw IOException"); + } + + public String toString() { + return data.toString(); + } + } + + private File notExist; + + private File fileWithContent; + + private File readOnly; + + private File secret; + + private TimeZone defaultTimeZone; + + /** + * @tests java.util.Formatter#Formatter() + */ + public void test_Constructor() { + Formatter f = new Formatter(); + assertNotNull(f); + assertTrue(f.out() instanceof StringBuilder); + assertEquals(f.locale(), Locale.getDefault()); + assertNotNull(f.toString()); + } + + /** + * @tests java.util.Formatter#Formatter(Appendable) + */ + public void test_ConstructorLjava_lang_Appendable() { + MockAppendable ma = new MockAppendable(); + Formatter f1 = new Formatter(ma); + assertEquals(ma, f1.out()); + assertEquals(f1.locale(), Locale.getDefault()); + assertNotNull(f1.toString()); + + Formatter f2 = new Formatter((Appendable) null); + /* + * If a(the input param) is null then a StringBuilder will be created + * and the output can be attained by invoking the out() method. But RI + * raises an error of FormatterClosedException when invoking out() or + * toString(). + */ + Appendable sb = f2.out(); + assertTrue(sb instanceof StringBuilder); + assertNotNull(f2.toString()); + } + + /** + * @tests java.util.Formatter#Formatter(Locale) + */ + public void test_ConstructorLjava_util_Locale() { + Formatter f1 = new Formatter(Locale.FRANCE); + assertTrue(f1.out() instanceof StringBuilder); + assertEquals(f1.locale(), Locale.FRANCE); + assertNotNull(f1.toString()); + + Formatter f2 = new Formatter((Locale) null); + assertNull(f2.locale()); + assertTrue(f2.out() instanceof StringBuilder); + assertNotNull(f2.toString()); + } + + /** + * @tests java.util.Formatter#Formatter(Appendable, Locale) + */ + public void test_ConstructorLjava_lang_AppendableLjava_util_Locale() { + MockAppendable ma = new MockAppendable(); + Formatter f1 = new Formatter(ma, Locale.CANADA); + assertEquals(ma, f1.out()); + assertEquals(f1.locale(), Locale.CANADA); + + Formatter f2 = new Formatter(ma, null); + assertNull(f2.locale()); + assertEquals(ma, f1.out()); + + Formatter f3 = new Formatter(null, Locale.GERMAN); + assertEquals(f3.locale(), Locale.GERMAN); + assertTrue(f3.out() instanceof StringBuilder); + } + + /** + * @tests java.util.Formatter#Formatter(String) + */ + public void test_ConstructorLjava_lang_String() throws IOException { + Formatter f = null; + try { + f = new Formatter((String) null); + fail("should throw NullPointerException"); + } catch (NullPointerException e1) { + // expected + } + + f = new Formatter(notExist.getPath()); + assertEquals(f.locale(), Locale.getDefault()); + f.close(); + + f = new Formatter(fileWithContent.getPath()); + assertEquals(0, fileWithContent.length()); + f.close(); + + // FIXME This exception will not be thrown out on linux. + try { + f = new Formatter(readOnly.getPath()); + fail("should throw FileNotFoundException"); + } catch (FileNotFoundException e) { + // expected + } + + SecurityManager oldsm = System.getSecurityManager(); + System.setSecurityManager(new MockSecurityManager()); + try { + f = new Formatter(secret.getPath()); + fail("should throw SecurityException"); + } catch (SecurityException se) { + // expected + } finally { + System.setSecurityManager(oldsm); + } + } + + /** + * @tests java.util.Formatter#Formatter(String, String) + */ + public void test_ConstructorLjava_lang_StringLjava_lang_String() + throws IOException { + Formatter f = null; + try { + f = new Formatter((String) null, Charset.defaultCharset().name()); + fail("should throw NullPointerException"); + } catch (NullPointerException e1) { + // expected + } + + try { + f = new Formatter(notExist.getPath(), null); + fail("should throw NullPointerException"); + } catch (NullPointerException e2) { + // expected + } + + f = new Formatter(notExist.getPath(), Charset.defaultCharset().name()); + assertEquals(f.locale(), Locale.getDefault()); + f.close(); + + try { + f = new Formatter(notExist.getPath(), "ISO 1111-1"); + fail("should throw UnsupportedEncodingException"); + } catch (UnsupportedEncodingException e1) { + // expected + } + + f = new Formatter(fileWithContent.getPath(), "UTF-16BE"); + assertEquals(0, fileWithContent.length()); + f.close(); + + // FIXME This exception will not be thrown out on linux. + try { + f = new Formatter(readOnly.getPath(), "UTF-16BE"); + fail("should throw FileNotFoundException"); + } catch (FileNotFoundException e) { + // expected + } + + SecurityManager oldsm = System.getSecurityManager(); + System.setSecurityManager(new MockSecurityManager()); + try { + f = new Formatter(secret.getPath(), "UTF-16BE"); + fail("should throw SecurityException"); + } catch (SecurityException se) { + // expected + } finally { + System.setSecurityManager(oldsm); + } + } + + /** + * @tests java.util.Formatter#Formatter(String, String, Locale) + */ + public void test_ConstructorLjava_lang_StringLjava_lang_StringLjava_util_Locale() + throws IOException { + Formatter f = null; + try { + f = new Formatter((String) null, Charset.defaultCharset().name(), + Locale.KOREA); + fail("should throw NullPointerException"); + } catch (NullPointerException e1) { + // expected + } + + try { + f = new Formatter(notExist.getPath(), null, Locale.KOREA); + fail("should throw NullPointerException"); + } catch (NullPointerException e2) { + // expected + } + + f = new Formatter(notExist.getPath(), Charset.defaultCharset().name(), + null); + assertNotNull(f); + f.close(); + + f = new Formatter(notExist.getPath(), Charset.defaultCharset().name(), + Locale.KOREA); + assertEquals(f.locale(), Locale.KOREA); + f.close(); + + try { + f = new Formatter(notExist.getPath(), "ISO 1111-1", Locale.CHINA); + fail("should throw UnsupportedEncodingException"); + } catch (UnsupportedEncodingException e1) { + // expected + } + + f = new Formatter(fileWithContent.getPath(), "UTF-16BE", + Locale.CANADA_FRENCH); + assertEquals(0, fileWithContent.length()); + f.close(); + + try { + f = new Formatter(readOnly.getPath(), Charset.defaultCharset() + .name(), Locale.ITALY); + fail("should throw FileNotFoundException"); + } catch (FileNotFoundException e) { + // expected + } + + SecurityManager oldsm = System.getSecurityManager(); + System.setSecurityManager(new MockSecurityManager()); + try { + f = new Formatter(secret.getPath(), + Charset.defaultCharset().name(), Locale.SIMPLIFIED_CHINESE); + fail("should throw SecurityException"); + } catch (SecurityException se) { + // expected + } finally { + System.setSecurityManager(oldsm); + } + } + + /** + * @tests java.util.Formatter#Formatter(File) + */ + public void test_ConstructorLjava_io_File() throws IOException { + Formatter f = null; + try { + f = new Formatter((File) null); + fail("should throw NullPointerException"); + } catch (NullPointerException e1) { + // expected + } + + f = new Formatter(notExist); + assertEquals(f.locale(), Locale.getDefault()); + f.close(); + + f = new Formatter(fileWithContent); + assertEquals(0, fileWithContent.length()); + f.close(); + + // FIXME This exception will not be thrown out on linux. + try { + f = new Formatter(readOnly); + fail("should throw FileNotFoundException"); + } catch (FileNotFoundException e) { + // expected + } + + SecurityManager oldsm = System.getSecurityManager(); + System.setSecurityManager(new MockSecurityManager()); + try { + f = new Formatter(secret); + fail("should throw SecurityException"); + } catch (SecurityException se) { + // expected + } finally { + System.setSecurityManager(oldsm); + } + } + + /** + * @tests java.util.Formatter#Formatter(File, String) + */ + public void test_ConstructorLjava_io_FileLjava_lang_String() + throws IOException { + Formatter f = null; + try { + f = new Formatter((File) null, Charset.defaultCharset().name()); + fail("should throw NullPointerException"); + } catch (NullPointerException e1) { + // expected + } + + f = new Formatter(notExist, Charset.defaultCharset().name()); + assertEquals(f.locale(), Locale.getDefault()); + f.close(); + + f = new Formatter(fileWithContent, "UTF-16BE"); + assertEquals(0, fileWithContent.length()); + f.close(); + + // FIXME This exception will not be thrown out on linux. + try { + f = new Formatter(readOnly, Charset.defaultCharset().name()); + fail("should throw FileNotFoundException"); + } catch (FileNotFoundException e) { + // expected + } + + SecurityManager oldsm = System.getSecurityManager(); + System.setSecurityManager(new MockSecurityManager()); + try { + f = new Formatter(secret, Charset.defaultCharset().name()); + fail("should throw SecurityException"); + } catch (SecurityException se) { + // expected + } finally { + System.setSecurityManager(oldsm); + } + + try { + f = new Formatter(notExist, null); + fail("should throw NullPointerException"); + } catch (NullPointerException e2) { + // expected + } finally { + if (notExist.exists()) { + // Fail on RI on Windows, because output stream is created and + // not closed when exception thrown + assertTrue(notExist.delete()); + } + } + + try { + f = new Formatter(notExist, "ISO 1111-1"); + fail("should throw UnsupportedEncodingException"); + } catch (UnsupportedEncodingException e1) { + // expected + } finally { + if (notExist.exists()) { + // Fail on RI on Windows, because output stream is created and + // not closed when exception thrown + assertTrue(notExist.delete()); + } + } + } + + /** + * @tests java.util.Formatter#Formatter(File, String, Locale) + */ + public void test_ConstructorLjava_io_FileLjava_lang_StringLjava_util_Locale() + throws IOException { + Formatter f = null; + try { + f = new Formatter((File) null, Charset.defaultCharset().name(), + Locale.KOREA); + fail("should throw NullPointerException"); + } catch (NullPointerException e1) { + // expected + } + + try { + f = new Formatter(notExist, null, Locale.KOREA); + fail("should throw NullPointerException"); + } catch (NullPointerException e2) { + // expected + } + + f = new Formatter(notExist, Charset.defaultCharset().name(), null); + assertNotNull(f); + f.close(); + + f = new Formatter(notExist, Charset.defaultCharset().name(), + Locale.KOREA); + assertEquals(f.locale(), Locale.KOREA); + f.close(); + + try { + f = new Formatter(notExist, "ISO 1111-1", Locale.CHINA); + fail("should throw UnsupportedEncodingException"); + } catch (UnsupportedEncodingException e1) { + // expected + } + f = new Formatter(fileWithContent.getPath(), "UTF-16BE", + Locale.CANADA_FRENCH); + assertEquals(0, fileWithContent.length()); + f.close(); + + // FIXME This exception will not be thrown out on linux. + try { + f = new Formatter(readOnly.getPath(), Charset.defaultCharset() + .name(), Locale.ITALY); + fail("should throw FileNotFoundException"); + } catch (FileNotFoundException e) { + // expected + } + + SecurityManager oldsm = System.getSecurityManager(); + System.setSecurityManager(new MockSecurityManager()); + try { + f = new Formatter(secret.getPath(), + Charset.defaultCharset().name(), Locale.SIMPLIFIED_CHINESE); + fail("should throw SecurityException"); + } catch (SecurityException se) { + // expected + } finally { + System.setSecurityManager(oldsm); + } + } + + /** + * @tests java.util.Formatter#Formatter(PrintStream) + */ + public void test_ConstructorLjava_io_PrintStream() throws IOException { + Formatter f = null; + try { + f = new Formatter((PrintStream) null); + fail("should throw NullPointerException"); + } catch (NullPointerException e1) { + // expected + } + + PrintStream ps = new PrintStream(notExist, "UTF-16BE"); + f = new Formatter(ps); + assertEquals(Locale.getDefault(), f.locale()); + f.close(); + } + + /** + * @tests java.util.Formatter#Formatter(OutputStream) + */ + public void test_ConstructorLjava_io_OutputStream() throws IOException { + Formatter f = null; + try { + f = new Formatter((OutputStream) null); + fail("should throw NullPointerException"); + } catch (NullPointerException e1) { + // expected + } + + OutputStream os = new FileOutputStream(notExist); + f = new Formatter(os); + assertEquals(Locale.getDefault(), f.locale()); + f.close(); + } + + /** + * @tests java.util.Formatter#Formatter(OutputStream, String) + */ + public void test_ConstructorLjava_io_OutputStreamLjava_lang_String() + throws IOException { + Formatter f = null; + try { + f = new Formatter((OutputStream) null, Charset.defaultCharset() + .name()); + fail("should throw NullPointerException"); + } catch (NullPointerException e1) { + // expected + } + + OutputStream os = null; + try { + os = new FileOutputStream(notExist); + f = new Formatter(os, null); + fail("should throw NullPointerException"); + } catch (NullPointerException e2) { + // expected + } finally { + os.close(); + } + + try { + os = new PipedOutputStream(); + f = new Formatter(os, "TMP-1111"); + fail("should throw UnsupportedEncodingException"); + } catch (UnsupportedEncodingException e1) { + // expected + } finally { + os.close(); + } + + os = new FileOutputStream(fileWithContent); + f = new Formatter(os, "UTF-16BE"); + assertEquals(Locale.getDefault(), f.locale()); + f.close(); + } + + /** + * Test method for 'java.util.Formatter.Formatter(OutputStream, String, + * Locale) + */ + public void test_ConstructorLjava_io_OutputStreamLjava_lang_StringLjava_util_Locale() + throws IOException { + Formatter f = null; + try { + f = new Formatter((OutputStream) null, Charset.defaultCharset() + .name(), Locale.getDefault()); + fail("should throw NullPointerException"); + } catch (NullPointerException e1) { + // expected + } + + OutputStream os = null; + try { + os = new FileOutputStream(notExist); + f = new Formatter(os, null, Locale.getDefault()); + fail("should throw NullPointerException"); + } catch (NullPointerException e2) { + // expected + } finally { + os.close(); + } + + os = new FileOutputStream(notExist); + f = new Formatter(os, Charset.defaultCharset().name(), null); + f.close(); + + try { + os = new PipedOutputStream(); + f = new Formatter(os, "TMP-1111", Locale.getDefault()); + fail("should throw UnsupportedEncodingException"); + } catch (UnsupportedEncodingException e1) { + // expected + } + + os = new FileOutputStream(fileWithContent); + f = new Formatter(os, "UTF-16BE", Locale.ENGLISH); + assertEquals(Locale.ENGLISH, f.locale()); + f.close(); + } + + /** + * @tests java.util.Formatter#locale() + */ + public void test_locale() { + Formatter f = null; + f = new Formatter((Locale) null); + assertNull(f.locale()); + + f.close(); + try { + f.locale(); + fail("should throw FormatterClosedException"); + } catch (FormatterClosedException e) { + // expected + } + } + + /** + * @tests java.util.Formatter#out() + */ + public void test_out() { + Formatter f = null; + f = new Formatter(); + assertNotNull(f.out()); + assertTrue(f.out() instanceof StringBuilder); + f.close(); + try { + f.out(); + fail("should throw FormatterClosedException"); + } catch (FormatterClosedException e) { + // expected + } + + } + + /** + * @tests java.util.Formatter#flush() + */ + public void test_flush() throws IOException { + Formatter f = null; + f = new Formatter(notExist); + assertTrue(f instanceof Flushable); + f.close(); + try { + f.flush(); + fail("should throw FormatterClosedException"); + } catch (FormatterClosedException e) { + // expected + } + + f = new Formatter(); + // For destination that does not implement Flushable + // No exception should be thrown + f.flush(); + } + + /** + * @tests java.util.Formatter#close() + */ + public void test_close() throws IOException { + Formatter f = new Formatter(notExist); + assertTrue(f instanceof Closeable); + f.close(); + // close next time will not throw exception + f.close(); + assertNull(f.ioException()); + } + + /** + * @tests java.util.Formatter#toString() + */ + public void test_toString() { + Formatter f = new Formatter(); + assertNotNull(f.toString()); + assertEquals(f.out().toString(), f.toString()); + f.close(); + try { + f.toString(); + fail("should throw FormatterClosedException"); + } catch (FormatterClosedException e) { + // expected + } + } + + /** + * @tests java.util.Formatter#ioException() + */ + public void test_ioException() throws IOException { + Formatter f = null; + f = new Formatter(new MockDestination()); + assertNull(f.ioException()); + f.flush(); + assertNotNull(f.ioException()); + f.close(); + + MockDestination md = new MockDestination(); + f = new Formatter(md); + f.format("%s%s", "1", "2"); + // format stop working after IOException + assertNotNull(f.ioException()); + assertEquals("", f.toString()); + } + + /** + * @tests java.util.Formatter#format(String, Object...) for null parameter + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_null() { + Formatter f = new Formatter(); + try { + f.format((String) null, "parameter"); + fail("should throw NullPointerException"); + } catch (NullPointerException e) { + // expected + } + + f = new Formatter(); + f.format("hello", (Object[]) null); + assertEquals("hello", f.toString()); + } + + /** + * @tests java.util.Formatter#format(String, Object...) for argument index + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_ArgIndex() { + Formatter formatter = new Formatter(Locale.US); + formatter.format("%1$s%2$s%3$s%4$s%5$s%6$s%7$s%8$s%9$s%11$s%10$s", "1", + "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"); + assertEquals("1234567891110", formatter.toString()); + + formatter = new Formatter(Locale.JAPAN); + formatter.format("%0$s", "hello"); + assertEquals("hello", formatter.toString()); + + try { + formatter = new Formatter(Locale.US); + formatter.format("%-1$s", "1", "2"); + fail("should throw UnknownFormatConversionException"); + } catch (UnknownFormatConversionException e) { + // expected + } + + try { + formatter = new Formatter(Locale.US); + formatter.format("%$s", "hello", "2"); + fail("should throw UnknownFormatConversionException"); + } catch (UnknownFormatConversionException e) { + // expected + } + + try { + Formatter f = new Formatter(Locale.US); + f.format("%", "string"); + fail("should throw UnknownFormatConversionException"); + } catch (UnknownFormatConversionException e) { + // expected + } + + formatter = new Formatter(Locale.FRANCE); + formatter.format("%1$s%2$s%3$s%4$s%5$s%6$s%7$s%8$s%= 0 || Character.isDigit(i) + || Character.isLetter(i)) { + // Do not test 0-9, a-z, A-Z and characters in the chars array. + // They are characters used as flags, width or conversions + continue; + } + try { + f.format("%" + i + "s", 1); + fail("should throw UnknownFormatConversionException"); + } catch (UnknownFormatConversionException e) { + // expected + } + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for general + * conversion b/B + */ + public void test_format_LString$LObject_GeneralConversionB() { + final Object[][] triple = { + { Boolean.FALSE, "%3.2b", " fa", }, + { Boolean.FALSE, "%-4.6b", "false", }, + { Boolean.FALSE, "%.2b", "fa", }, + { Boolean.TRUE, "%3.2b", " tr", }, + { Boolean.TRUE, "%-4.6b", "true", }, + { Boolean.TRUE, "%.2b", "tr", }, + { new Character('c'), "%3.2b", " tr", }, + { new Character('c'), "%-4.6b", "true", }, + { new Character('c'), "%.2b", "tr", }, + { new Byte((byte) 0x01), "%3.2b", " tr", }, + { new Byte((byte) 0x01), "%-4.6b", "true", }, + { new Byte((byte) 0x01), "%.2b", "tr", }, + { new Short((short) 0x0001), "%3.2b", " tr", }, + { new Short((short) 0x0001), "%-4.6b", "true", }, + { new Short((short) 0x0001), "%.2b", "tr", }, + { new Integer(1), "%3.2b", " tr", }, + { new Integer(1), "%-4.6b", "true", }, + { new Integer(1), "%.2b", "tr", }, + { new Float(1.1f), "%3.2b", " tr", }, + { new Float(1.1f), "%-4.6b", "true", }, + { new Float(1.1f), "%.2b", "tr", }, + { new Double(1.1d), "%3.2b", " tr", }, + { new Double(1.1d), "%-4.6b", "true", }, + { new Double(1.1d), "%.2b", "tr", }, + { "", "%3.2b", " tr", }, + { "", "%-4.6b", "true", }, + { "", "%.2b", "tr", }, + { "string content", "%3.2b", " tr", }, + { "string content", "%-4.6b", "true", }, + { "string content", "%.2b", "tr", }, + { new MockFormattable(), "%3.2b", " tr", }, + { new MockFormattable(), "%-4.6b", "true", }, + { new MockFormattable(), "%.2b", "tr", }, + { (Object) null, "%3.2b", " fa", }, + { (Object) null, "%-4.6b", "false", }, + { (Object) null, "%.2b", "fa", }, + }; + + + final int input = 0; + final int pattern = 1; + final int output = 2; + Formatter f = null; + for (int i = 0; i < triple.length; i++) { + f = new Formatter(Locale.FRANCE); + f.format((String)triple[i][pattern], triple[i][input]); + assertEquals("triple[" + i + "]:" + triple[i][input] + + ",pattern[" + i + "]:" + triple[i][pattern], triple[i][output], f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format(((String)triple[i][pattern]).toUpperCase(Locale.US), triple[i][input]); + assertEquals("triple[" + i + "]:" + triple[i][input] + + ",pattern[" + i + "]:" + triple[i][pattern], ((String)triple[i][output]) + .toUpperCase(Locale.US), f.toString()); + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for general + * conversion type 's' and 'S' + */ + public void test_format_LString$LObject_GeneralConversionS() { + + final Object[][] triple = { + { Boolean.FALSE, "%2.3s", "fal", }, + { Boolean.FALSE, "%-6.4s", "fals ", }, + { Boolean.FALSE, "%.5s", "false", }, + { Boolean.TRUE, "%2.3s", "tru", }, + { Boolean.TRUE, "%-6.4s", "true ", }, + { Boolean.TRUE, "%.5s", "true", }, + { new Character('c'), "%2.3s", " c", }, + { new Character('c'), "%-6.4s", "c ", }, + { new Character('c'), "%.5s", "c", }, + { new Byte((byte) 0x01), "%2.3s", " 1", }, + { new Byte((byte) 0x01), "%-6.4s", "1 ", }, + { new Byte((byte) 0x01), "%.5s", "1", }, + { new Short((short) 0x0001), "%2.3s", " 1", }, + { new Short((short) 0x0001), "%-6.4s", "1 ", }, + { new Short((short) 0x0001), "%.5s", "1", }, + { new Integer(1), "%2.3s", " 1", }, + { new Integer(1), "%-6.4s", "1 ", }, + { new Integer(1), "%.5s", "1", }, + { new Float(1.1f), "%2.3s", "1.1", }, + { new Float(1.1f), "%-6.4s", "1.1 ", }, + { new Float(1.1f), "%.5s", "1.1", }, + { new Double(1.1d), "%2.3s", "1.1", }, + { new Double(1.1d), "%-6.4s", "1.1 ", }, + { new Double(1.1d), "%.5s", "1.1", }, + { "", "%2.3s", " ", }, + { "", "%-6.4s", " ", }, + { "", "%.5s", "", }, + { "string content", "%2.3s", "str", }, + { "string content", "%-6.4s", "stri ", }, + { "string content", "%.5s", "strin", }, + { new MockFormattable(), "%2.3s", "customized format function width: 2 precision: 3", }, + { new MockFormattable(), "%-6.4s", "customized format function width: 6 precision: 4", }, + { new MockFormattable(), "%.5s", "customized format function width: -1 precision: 5", }, + { (Object) null, "%2.3s", "nul", }, + { (Object) null, "%-6.4s", "null ", }, + { (Object) null, "%.5s", "null", }, + }; + + + final int input = 0; + final int pattern = 1; + final int output = 2; + Formatter f = null; + for (int i = 0; i < triple.length; i++) { + f = new Formatter(Locale.FRANCE); + f.format((String)triple[i][pattern], triple[i][input]); + assertEquals("triple[" + i + "]:" + triple[i][input] + + ",pattern[" + i + "]:" + triple[i][pattern], triple[i][output], f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format(((String)triple[i][pattern]).toUpperCase(Locale.US), triple[i][input]); + assertEquals("triple[" + i + "]:" + triple[i][input] + + ",pattern[" + i + "]:" + triple[i][pattern], ((String)triple[i][output]) + .toUpperCase(Locale.US), f.toString()); + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for general + * conversion type 'h' and 'H' + */ + public void test_format_LString$LObject_GeneralConversionH() { + + final Object[] input = { + Boolean.FALSE, + Boolean.TRUE, + new Character('c'), + new Byte((byte) 0x01), + new Short((short) 0x0001), + new Integer(1), + new Float(1.1f), + new Double(1.1d), + "", + "string content", + new MockFormattable(), + (Object) null, + }; + + Formatter f = null; + for (int i = 0; i < input.length - 1; i++) { + f = new Formatter(Locale.FRANCE); + f.format("%h", input[i]); + assertEquals("triple[" + i + "]:" + input[i], + Integer.toHexString(input[i].hashCode()), f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format("%H", input[i]); + assertEquals("triple[" + i + "]:" + input[i], + Integer.toHexString(input[i].hashCode()).toUpperCase(Locale.US), f.toString()); + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for general + * conversion other cases + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_GeneralConversionOther() { + /* + * In Turkish locale, the upper case of '\u0069' is '\u0130'. The + * following test indicate that '\u0069' is coverted to upper case + * without using the turkish locale. + */ + Formatter f = new Formatter(new Locale("tr")); + f.format("%S", "\u0069"); + assertEquals("\u0049", f.toString()); + + final Object[] input = { + Boolean.FALSE, + Boolean.TRUE, + new Character('c'), + new Byte((byte) 0x01), + new Short((short) 0x0001), + new Integer(1), + new Float(1.1f), + new Double(1.1d), + "", + "string content", + new MockFormattable(), + (Object) null, + }; + f = new Formatter(Locale.GERMAN); + for (int i = 0; i < input.length; i++) { + if (!(input[i] instanceof Formattable)) { + try { + f.format("%#s", input[i]); + /* + * fail on RI, spec says if the '#' flag is present and the + * argument is not a Formattable , then a + * FormatFlagsConversionMismatchException will be thrown. + */ + fail("should throw FormatFlagsConversionMismatchException"); + } catch (FormatFlagsConversionMismatchException e) { + // expected + } + } else { + f.format("%#s%<-#8s", input[i]); + assertEquals( + "customized format function width: -1 precision: -1customized format function width: 8 precision: -1", + f.toString()); + } + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for general + * conversion exception + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_GeneralConversionException() { + final String[] flagMismatch = { "%#b", "%+b", "% b", "%0b", "%,b", + "%(b", "%#B", "%+B", "% B", "%0B", "%,B", "%(B", "%#h", "%+h", + "% h", "%0h", "%,h", "%(h", "%#H", "%+H", "% H", "%0H", "%,H", + "%(H", "%+s", "% s", "%0s", "%,s", "%(s", "%+S", "% S", "%0S", + "%,S", "%(S" }; + + Formatter f = new Formatter(Locale.US); + + for (int i = 0; i < flagMismatch.length; i++) { + try { + f.format(flagMismatch[i], "something"); + fail("should throw FormatFlagsConversionMismatchException"); + } catch (FormatFlagsConversionMismatchException e) { + // expected + } + } + + final String[] missingWidth = { "%-b", "%-B", "%-h", "%-H", "%-s", + "%-S", }; + for (int i = 0; i < missingWidth.length; i++) { + try { + f.format(missingWidth[i], "something"); + fail("should throw MissingFormatWidthException"); + } catch (MissingFormatWidthException e) { + // expected + } + } + + // Regression test + f = new Formatter(); + try { + f.format("%c", (byte)-0x0001); + fail("Should throw IllegalFormatCodePointException"); + } catch (IllegalFormatCodePointException e) { + // expected + } + + f = new Formatter(); + try { + f.format("%c", (short)-0x0001); + fail("Should throw IllegalFormatCodePointException"); + } catch (IllegalFormatCodePointException e) { + // expected + } + + f = new Formatter(); + try { + f.format("%c", -0x0001); + fail("Should throw IllegalFormatCodePointException"); + } catch (IllegalFormatCodePointException e) { + // expected + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for Character + * conversion + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_CharacterConversion() { + Formatter f = new Formatter(Locale.US); + final Object[] illArgs = { Boolean.TRUE, new Float(1.1f), + new Double(1.1d), "string content", new Float(1.1f), new Date() }; + for (int i = 0; i < illArgs.length; i++) { + try { + f.format("%c", illArgs[i]); + fail("should throw IllegalFormatConversionException"); + } catch (IllegalFormatConversionException e) { + // expected + } + } + + try { + f.format("%c", Integer.MAX_VALUE); + fail("should throw IllegalFormatCodePointException"); + } catch (IllegalFormatCodePointException e) { + // expected + } + + try { + f.format("%#c", 'c'); + fail("should throw FormatFlagsConversionMismatchException"); + } catch (FormatFlagsConversionMismatchException e) { + // expected + } + + final Object[][] triple = { + {'c', "%c", "c"}, + {'c', "%-2c", "c "}, + {'\u0123', "%c", "\u0123"}, + {'\u0123', "%-2c", "\u0123 "}, + {(byte) 0x11, "%c", "\u0011"}, + {(byte) 0x11, "%-2c", "\u0011 "}, + {(short) 0x1111, "%c", "\u1111"}, + {(short) 0x1111, "%-2c", "\u1111 "}, + {0x11, "%c", "\u0011"}, + {0x11, "%-2c", "\u0011 "}, + }; + + final int input = 0; + final int pattern = 1; + final int output = 2; + for (int i = 0; i < triple.length; i++) { + f = new Formatter(Locale.US); + f.format((String)triple[i][pattern], triple[i][input]); + assertEquals(triple[i][output], f.toString()); + } + + f = new Formatter(Locale.US); + f.format("%c", 0x10000); + assertEquals(0x10000, f.toString().codePointAt(0)); + + try { + f.format("%2.2c", 'c'); + fail("should throw IllegalFormatPrecisionException"); + } catch (IllegalFormatPrecisionException e) { + // expected + } + + f = new Formatter(Locale.US); + f.format("%C", 'w'); + // error on RI, throw UnknownFormatConversionException + // RI do not support converter 'C' + assertEquals("W", f.toString()); + + f = new Formatter(Locale.JAPAN); + f.format("%Ced", 0x1111); + // error on RI, throw UnknownFormatConversionException + // RI do not support converter 'C' + assertEquals("\u1111ed", f.toString()); + } + + + + /** + * @tests java.util.Formatter#format(String, Object...) for legal + * Byte/Short/Integer/Long conversion type 'd' + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongConversionD() { + final Object[][] triple = { + { 0, "%d", "0" }, + { 0, "%10d", " 0" }, + { 0, "%-1d", "0" }, + { 0, "%+d", "+0" }, + { 0, "% d", " 0" }, + { 0, "%,d", "0" }, + { 0, "%(d", "0" }, + { 0, "%08d", "00000000" }, + { 0, "%-+,(11d", "+0 " }, + { 0, "%0 ,(11d", " 0000000000" }, + + { (byte) 0xff, "%d", "-1" }, + { (byte) 0xff, "%10d", " -1" }, + { (byte) 0xff, "%-1d", "-1" }, + { (byte) 0xff, "%+d", "-1" }, + { (byte) 0xff, "% d", "-1" }, + { (byte) 0xff, "%,d", "-1" }, + { (byte) 0xff, "%(d", "(1)" }, + { (byte) 0xff, "%08d", "-0000001" }, + { (byte) 0xff, "%-+,(11d", "(1) " }, + { (byte) 0xff, "%0 ,(11d", "(000000001)" }, + + { (short) 0xf123, "%d", "-3805" }, + { (short) 0xf123, "%10d", " -3805" }, + { (short) 0xf123, "%-1d", "-3805" }, + { (short) 0xf123, "%+d", "-3805" }, + { (short) 0xf123, "% d", "-3805" }, + { (short) 0xf123, "%,d", "-3.805" }, + { (short) 0xf123, "%(d", "(3805)" }, + { (short) 0xf123, "%08d", "-0003805" }, + { (short) 0xf123, "%-+,(11d", "(3.805) " }, + { (short) 0xf123, "%0 ,(11d", "(00003.805)" }, + + { 0x123456, "%d", "1193046" }, + { 0x123456, "%10d", " 1193046" }, + { 0x123456, "%-1d", "1193046" }, + { 0x123456, "%+d", "+1193046" }, + { 0x123456, "% d", " 1193046" }, + { 0x123456, "%,d", "1.193.046" }, + { 0x123456, "%(d", "1193046" }, + { 0x123456, "%08d", "01193046" }, + { 0x123456, "%-+,(11d", "+1.193.046 " }, + { 0x123456, "%0 ,(11d", " 01.193.046" }, + + { -3, "%d", "-3" }, + { -3, "%10d", " -3" }, + { -3, "%-1d", "-3" }, + { -3, "%+d", "-3" }, + { -3, "% d", "-3" }, + { -3, "%,d", "-3" }, + { -3, "%(d", "(3)" }, + { -3, "%08d", "-0000003" }, + { -3, "%-+,(11d", "(3) " }, + { -3, "%0 ,(11d", "(000000003)" }, + + { 0x7654321L, "%d", "124076833" }, + { 0x7654321L, "%10d", " 124076833" }, + { 0x7654321L, "%-1d", "124076833" }, + { 0x7654321L, "%+d", "+124076833" }, + { 0x7654321L, "% d", " 124076833" }, + { 0x7654321L, "%,d", "124.076.833" }, + { 0x7654321L, "%(d", "124076833" }, + { 0x7654321L, "%08d", "124076833" }, + { 0x7654321L, "%-+,(11d", "+124.076.833" }, + { 0x7654321L, "%0 ,(11d", " 124.076.833" }, + + { -1L, "%d", "-1" }, + { -1L, "%10d", " -1" }, + { -1L, "%-1d", "-1" }, + { -1L, "%+d", "-1" }, + { -1L, "% d", "-1" }, + { -1L, "%,d", "-1" }, + { -1L, "%(d", "(1)" }, + { -1L, "%08d", "-0000001" }, + { -1L, "%-+,(11d", "(1) " }, + { -1L, "%0 ,(11d", "(000000001)" }, + }; + + final int input = 0; + final int pattern = 1; + final int output = 2; + Formatter f; + for (int i = 0; i < triple.length; i++) { + f = new Formatter(Locale.GERMAN); + f.format((String) triple[i][pattern], + triple[i][input]); + assertEquals("triple[" + i + "]:" + triple[i][input] + ",pattern[" + + i + "]:" + triple[i][pattern], triple[i][output], f + .toString()); + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for legal + * Byte/Short/Integer/Long conversion type 'o' + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongConversionO() { + final Object[][] triple = { + { 0, "%o", "0" }, + { 0, "%-6o", "0 " }, + { 0, "%08o", "00000000" }, + { 0, "%#o", "00" }, + { 0, "%0#11o", "00000000000" }, + { 0, "%-#9o", "00 " }, + + { (byte) 0xff, "%o", "377" }, + { (byte) 0xff, "%-6o", "377 " }, + { (byte) 0xff, "%08o", "00000377" }, + { (byte) 0xff, "%#o", "0377" }, + { (byte) 0xff, "%0#11o", "00000000377" }, + { (byte) 0xff, "%-#9o", "0377 " }, + + { (short) 0xf123, "%o", "170443" }, + { (short) 0xf123, "%-6o", "170443" }, + { (short) 0xf123, "%08o", "00170443" }, + { (short) 0xf123, "%#o", "0170443" }, + { (short) 0xf123, "%0#11o", "00000170443" }, + { (short) 0xf123, "%-#9o", "0170443 " }, + + { 0x123456, "%o", "4432126" }, + { 0x123456, "%-6o", "4432126" }, + { 0x123456, "%08o", "04432126" }, + { 0x123456, "%#o", "04432126" }, + { 0x123456, "%0#11o", "00004432126" }, + { 0x123456, "%-#9o", "04432126 " }, + + { -3, "%o", "37777777775" }, + { -3, "%-6o", "37777777775" }, + { -3, "%08o", "37777777775" }, + { -3, "%#o", "037777777775" }, + { -3, "%0#11o", "037777777775" }, + { -3, "%-#9o", "037777777775" }, + + { 0x7654321L, "%o", "731241441" }, + { 0x7654321L, "%-6o", "731241441" }, + { 0x7654321L, "%08o", "731241441" }, + { 0x7654321L, "%#o", "0731241441" }, + { 0x7654321L, "%0#11o", "00731241441" }, + { 0x7654321L, "%-#9o", "0731241441" }, + + { -1L, "%o", "1777777777777777777777" }, + { -1L, "%-6o", "1777777777777777777777" }, + { -1L, "%08o", "1777777777777777777777" }, + { -1L, "%#o", "01777777777777777777777" }, + { -1L, "%0#11o", "01777777777777777777777" }, + { -1L, "%-#9o", "01777777777777777777777" }, + }; + + final int input = 0; + final int pattern = 1; + final int output = 2; + Formatter f; + for (int i = 0; i < triple.length; i++) { + f = new Formatter(Locale.ITALY); + f.format((String) triple[i][pattern], + triple[i][input]); + assertEquals("triple[" + i + "]:" + triple[i][input] + ",pattern[" + + i + "]:" + triple[i][pattern], triple[i][output], f + .toString()); + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for legal + * Byte/Short/Integer/Long conversion type 'x' and 'X' + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongConversionX() { + final Object[][] triple = { + { 0, "%x", "0" }, + { 0, "%-8x", "0 " }, + { 0, "%06x", "000000" }, + { 0, "%#x", "0x0" }, + { 0, "%0#12x", "0x0000000000" }, + { 0, "%-#9x", "0x0 " }, + + { (byte) 0xff, "%x", "ff" }, + { (byte) 0xff, "%-8x", "ff " }, + { (byte) 0xff, "%06x", "0000ff" }, + { (byte) 0xff, "%#x", "0xff" }, + { (byte) 0xff, "%0#12x", "0x00000000ff" }, + { (byte) 0xff, "%-#9x", "0xff " }, + + { (short) 0xf123, "%x", "f123" }, + { (short) 0xf123, "%-8x", "f123 " }, + { (short) 0xf123, "%06x", "00f123" }, + { (short) 0xf123, "%#x", "0xf123" }, + { (short) 0xf123, "%0#12x", "0x000000f123" }, + { (short) 0xf123, "%-#9x", "0xf123 " }, + + { 0x123456, "%x", "123456" }, + { 0x123456, "%-8x", "123456 " }, + { 0x123456, "%06x", "123456" }, + { 0x123456, "%#x", "0x123456" }, + { 0x123456, "%0#12x", "0x0000123456" }, + { 0x123456, "%-#9x", "0x123456 " }, + + { -3, "%x", "fffffffd" }, + { -3, "%-8x", "fffffffd" }, + { -3, "%06x", "fffffffd" }, + { -3, "%#x", "0xfffffffd" }, + { -3, "%0#12x", "0x00fffffffd" }, + { -3, "%-#9x", "0xfffffffd" }, + + { 0x7654321L, "%x", "7654321" }, + { 0x7654321L, "%-8x", "7654321 " }, + { 0x7654321L, "%06x", "7654321" }, + { 0x7654321L, "%#x", "0x7654321" }, + { 0x7654321L, "%0#12x", "0x0007654321" }, + { 0x7654321L, "%-#9x", "0x7654321" }, + + { -1L, "%x", "ffffffffffffffff" }, + { -1L, "%-8x", "ffffffffffffffff" }, + { -1L, "%06x", "ffffffffffffffff" }, + { -1L, "%#x", "0xffffffffffffffff" }, + { -1L, "%0#12x", "0xffffffffffffffff" }, + { -1L, "%-#9x", "0xffffffffffffffff" }, + }; + + final int input = 0; + final int pattern = 1; + final int output = 2; + Formatter f; + for (int i = 0; i < triple.length; i++) { + f = new Formatter(Locale.FRANCE); + f.format((String) triple[i][pattern], + triple[i][input]); + assertEquals("triple[" + i + "]:" + triple[i][input] + ",pattern[" + + i + "]:" + triple[i][pattern], triple[i][output], f + .toString()); + + f = new Formatter(Locale.FRANCE); + f.format((String) triple[i][pattern], + triple[i][input]); + assertEquals("triple[" + i + "]:" + triple[i][input] + ",pattern[" + + i + "]:" + triple[i][pattern], triple[i][output], f + .toString()); + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for Date/Time + * conversion + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_DateTimeConversion() { + Formatter f = null; + Date now = new Date(1147327147578L); + + Calendar paris = Calendar.getInstance(TimeZone + .getTimeZone("Europe/Paris"), Locale.FRANCE); + paris.set(2006, 4, 8, 12, 0, 0); + paris.set(Calendar.MILLISECOND, 453); + Calendar china = Calendar.getInstance( + TimeZone.getTimeZone("GMT-08:00"), Locale.CHINA); + china.set(2006, 4, 8, 12, 0, 0); + china.set(Calendar.MILLISECOND, 609); + + final Object[][] lowerCaseGermanTriple = { + {0L, 'a', "Do"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'a', "So"}, //$NON-NLS-2$ + {-1000L, 'a', "Do"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'a', "Do"}, //$NON-NLS-2$ + {paris, 'a', "Mo"}, //$NON-NLS-2$ + {china, 'a', "Mo"}, //$NON-NLS-2$ + {0L, 'b', "Jan"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'b', "Aug"}, //$NON-NLS-2$ + {-1000L, 'b', "Jan"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'b', "Mai"}, //$NON-NLS-2$ + {paris, 'b', "Mai"}, //$NON-NLS-2$ + {china, 'b', "Mai"}, //$NON-NLS-2$ + {0L, 'c', "Do Jan 01 08:00:00 CST 1970"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'c', "So Aug 17 15:12:55 CST 292278994"}, //$NON-NLS-2$ + {-1000L, 'c', "Do Jan 01 07:59:59 CST 1970"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'c', "Do Mai 11 13:59:07 CST 2006"}, //$NON-NLS-2$ + {paris, 'c', "Mo Mai 08 12:00:00 CEST 2006"}, //$NON-NLS-2$ + {china, 'c', "Mo Mai 08 12:00:00 GMT-08:00 2006"}, //$NON-NLS-2$ + {0L, 'd', "01"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'd', "17"}, //$NON-NLS-2$ + {-1000L, 'd', "01"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'd', "11"}, //$NON-NLS-2$ + {paris, 'd', "08"}, //$NON-NLS-2$ + {china, 'd', "08"}, //$NON-NLS-2$ + {0L, 'e', "1"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'e', "17"}, //$NON-NLS-2$ + {-1000L, 'e', "1"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'e', "11"}, //$NON-NLS-2$ + {paris, 'e', "8"}, //$NON-NLS-2$ + {china, 'e', "8"}, //$NON-NLS-2$ + {0L, 'h', "Jan"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'h', "Aug"}, //$NON-NLS-2$ + {-1000L, 'h', "Jan"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'h', "Mai"}, //$NON-NLS-2$ + {paris, 'h', "Mai"}, //$NON-NLS-2$ + {china, 'h', "Mai"}, //$NON-NLS-2$ + {0L, 'j', "001"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'j', "229"}, //$NON-NLS-2$ + {-1000L, 'j', "001"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'j', "131"}, //$NON-NLS-2$ + {paris, 'j', "128"}, //$NON-NLS-2$ + {china, 'j', "128"}, //$NON-NLS-2$ + {0L, 'k', "8"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'k', "15"}, //$NON-NLS-2$ + {-1000L, 'k', "7"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'k', "13"}, //$NON-NLS-2$ + {paris, 'k', "12"}, //$NON-NLS-2$ + {china, 'k', "12"}, //$NON-NLS-2$ + {0L, 'l', "8"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'l', "3"}, //$NON-NLS-2$ + {-1000L, 'l', "7"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'l', "1"}, //$NON-NLS-2$ + {paris, 'l', "12"}, //$NON-NLS-2$ + {china, 'l', "12"}, //$NON-NLS-2$ + {0L, 'm', "01"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'm', "08"}, //$NON-NLS-2$ + {-1000L, 'm', "01"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'm', "05"}, //$NON-NLS-2$ + {paris, 'm', "05"}, //$NON-NLS-2$ + {china, 'm', "05"}, //$NON-NLS-2$ + {0L, 'p', "am"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'p', "pm"}, //$NON-NLS-2$ + {-1000L, 'p', "am"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'p', "pm"}, //$NON-NLS-2$ + {paris, 'p', "pm"}, //$NON-NLS-2$ + {china, 'p', "pm"}, //$NON-NLS-2$ + {0L, 'r', "08:00:00 AM"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'r', "03:12:55 PM"}, //$NON-NLS-2$ + {-1000L, 'r', "07:59:59 AM"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'r', "01:59:07 PM"}, //$NON-NLS-2$ + {paris, 'r', "12:00:00 PM"}, //$NON-NLS-2$ + {china, 'r', "12:00:00 PM"}, //$NON-NLS-2$ + {0L, 's', "0"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 's', "9223372036854775"}, //$NON-NLS-2$ + {-1000L, 's', "-1"}, //$NON-NLS-2$ + {new Date(1147327147578L), 's', "1147327147"}, //$NON-NLS-2$ + {paris, 's', "1147082400"}, //$NON-NLS-2$ + {china, 's', "1147118400"}, //$NON-NLS-2$ + {0L, 'y', "70"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'y', "94"}, //$NON-NLS-2$ + {-1000L, 'y', "70"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'y', "06"}, //$NON-NLS-2$ + {paris, 'y', "06"}, //$NON-NLS-2$ + {china, 'y', "06"}, //$NON-NLS-2$ + {0L, 'z', "+0800"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'z', "+0800"}, //$NON-NLS-2$ + {-1000L, 'z', "+0800"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'z', "+0800"}, //$NON-NLS-2$ + {paris, 'z', "+0100"}, //$NON-NLS-2$ + {china, 'z', "-0800"}, //$NON-NLS-2$ + + }; + + final Object[][] lowerCaseFranceTriple = { + {0L, 'a', "jeu."}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'a', "dim."}, //$NON-NLS-2$ + {-1000L, 'a', "jeu."}, //$NON-NLS-2$ + {new Date(1147327147578L), 'a', "jeu."}, //$NON-NLS-2$ + {paris, 'a', "lun."}, //$NON-NLS-2$ + {china, 'a', "lun."}, //$NON-NLS-2$ + {0L, 'b', "janv."}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'b', "ao\u00fbt"}, //$NON-NLS-2$ + {-1000L, 'b', "janv."}, //$NON-NLS-2$ + {new Date(1147327147578L), 'b', "mai"}, //$NON-NLS-2$ + {paris, 'b', "mai"}, //$NON-NLS-2$ + {china, 'b', "mai"}, //$NON-NLS-2$ + {0L, 'c', "jeu. janv. 01 08:00:00 CST 1970"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'c', "dim. ao\u00fbt 17 15:12:55 CST 292278994"}, //$NON-NLS-2$ + {-1000L, 'c', "jeu. janv. 01 07:59:59 CST 1970"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'c', "jeu. mai 11 13:59:07 CST 2006"}, //$NON-NLS-2$ + {paris, 'c', "lun. mai 08 12:00:00 CEST 2006"}, //$NON-NLS-2$ + {china, 'c', "lun. mai 08 12:00:00 GMT-08:00 2006"}, //$NON-NLS-2$ + {0L, 'd', "01"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'd', "17"}, //$NON-NLS-2$ + {-1000L, 'd', "01"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'd', "11"}, //$NON-NLS-2$ + {paris, 'd', "08"}, //$NON-NLS-2$ + {china, 'd', "08"}, //$NON-NLS-2$ + {0L, 'e', "1"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'e', "17"}, //$NON-NLS-2$ + {-1000L, 'e', "1"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'e', "11"}, //$NON-NLS-2$ + {paris, 'e', "8"}, //$NON-NLS-2$ + {china, 'e', "8"}, //$NON-NLS-2$ + {0L, 'h', "janv."}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'h', "ao\u00fbt"}, //$NON-NLS-2$ + {-1000L, 'h', "janv."}, //$NON-NLS-2$ + {new Date(1147327147578L), 'h', "mai"}, //$NON-NLS-2$ + {paris, 'h', "mai"}, //$NON-NLS-2$ + {china, 'h', "mai"}, //$NON-NLS-2$ + {0L, 'j', "001"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'j', "229"}, //$NON-NLS-2$ + {-1000L, 'j', "001"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'j', "131"}, //$NON-NLS-2$ + {paris, 'j', "128"}, //$NON-NLS-2$ + {china, 'j', "128"}, //$NON-NLS-2$ + {0L, 'k', "8"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'k', "15"}, //$NON-NLS-2$ + {-1000L, 'k', "7"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'k', "13"}, //$NON-NLS-2$ + {paris, 'k', "12"}, //$NON-NLS-2$ + {china, 'k', "12"}, //$NON-NLS-2$ + {0L, 'l', "8"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'l', "3"}, //$NON-NLS-2$ + {-1000L, 'l', "7"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'l', "1"}, //$NON-NLS-2$ + {paris, 'l', "12"}, //$NON-NLS-2$ + {china, 'l', "12"}, //$NON-NLS-2$ + {0L, 'm', "01"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'm', "08"}, //$NON-NLS-2$ + {-1000L, 'm', "01"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'm', "05"}, //$NON-NLS-2$ + {paris, 'm', "05"}, //$NON-NLS-2$ + {china, 'm', "05"}, //$NON-NLS-2$ + {0L, 'p', "am"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'p', "pm"}, //$NON-NLS-2$ + {-1000L, 'p', "am"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'p', "pm"}, //$NON-NLS-2$ + {paris, 'p', "pm"}, //$NON-NLS-2$ + {china, 'p', "pm"}, //$NON-NLS-2$ + {0L, 'r', "08:00:00 AM"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'r', "03:12:55 PM"}, //$NON-NLS-2$ + {-1000L, 'r', "07:59:59 AM"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'r', "01:59:07 PM"}, //$NON-NLS-2$ + {paris, 'r', "12:00:00 PM"}, //$NON-NLS-2$ + {china, 'r', "12:00:00 PM"}, //$NON-NLS-2$ + {0L, 's', "0"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 's', "9223372036854775"}, //$NON-NLS-2$ + {-1000L, 's', "-1"}, //$NON-NLS-2$ + {new Date(1147327147578L), 's', "1147327147"}, //$NON-NLS-2$ + {paris, 's', "1147082400"}, //$NON-NLS-2$ + {china, 's', "1147118400"}, //$NON-NLS-2$ + {0L, 'y', "70"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'y', "94"}, //$NON-NLS-2$ + {-1000L, 'y', "70"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'y', "06"}, //$NON-NLS-2$ + {paris, 'y', "06"}, //$NON-NLS-2$ + {china, 'y', "06"}, //$NON-NLS-2$ + {0L, 'z', "+0800"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'z', "+0800"}, //$NON-NLS-2$ + {-1000L, 'z', "+0800"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'z', "+0800"}, //$NON-NLS-2$ + {paris, 'z', "+0100"}, //$NON-NLS-2$ + {china, 'z', "-0800"}, //$NON-NLS-2$ + + }; + + final Object[][] lowerCaseJapanTriple = { + {0L, 'a', "\u6728"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'a', "\u65e5"}, //$NON-NLS-2$ + {-1000L, 'a', "\u6728"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'a', "\u6728"}, //$NON-NLS-2$ + {paris, 'a', "\u6708"}, //$NON-NLS-2$ + {china, 'a', "\u6708"}, //$NON-NLS-2$ + {0L, 'b', "1"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'b', "8"}, //$NON-NLS-2$ + {-1000L, 'b', "1"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'b', "5"}, //$NON-NLS-2$ + {paris, 'b', "5"}, //$NON-NLS-2$ + {china, 'b', "5"}, //$NON-NLS-2$ + {0L, 'c', "\u6728 1 01 08:00:00 CST 1970"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'c', "\u65e5 8 17 15:12:55 CST 292278994"}, //$NON-NLS-2$ + {-1000L, 'c', "\u6728 1 01 07:59:59 CST 1970"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'c', "\u6728 5 11 13:59:07 CST 2006"}, //$NON-NLS-2$ + {paris, 'c', "\u6708 5 08 12:00:00 CEST 2006"}, //$NON-NLS-2$ + {china, 'c', "\u6708 5 08 12:00:00 GMT-08:00 2006"}, //$NON-NLS-2$ + {0L, 'd', "01"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'd', "17"}, //$NON-NLS-2$ + {-1000L, 'd', "01"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'd', "11"}, //$NON-NLS-2$ + {paris, 'd', "08"}, //$NON-NLS-2$ + {china, 'd', "08"}, //$NON-NLS-2$ + {0L, 'e', "1"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'e', "17"}, //$NON-NLS-2$ + {-1000L, 'e', "1"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'e', "11"}, //$NON-NLS-2$ + {paris, 'e', "8"}, //$NON-NLS-2$ + {china, 'e', "8"}, //$NON-NLS-2$ + {0L, 'h', "1"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'h', "8"}, //$NON-NLS-2$ + {-1000L, 'h', "1"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'h', "5"}, //$NON-NLS-2$ + {paris, 'h', "5"}, //$NON-NLS-2$ + {china, 'h', "5"}, //$NON-NLS-2$ + {0L, 'j', "001"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'j', "229"}, //$NON-NLS-2$ + {-1000L, 'j', "001"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'j', "131"}, //$NON-NLS-2$ + {paris, 'j', "128"}, //$NON-NLS-2$ + {china, 'j', "128"}, //$NON-NLS-2$ + {0L, 'k', "8"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'k', "15"}, //$NON-NLS-2$ + {-1000L, 'k', "7"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'k', "13"}, //$NON-NLS-2$ + {paris, 'k', "12"}, //$NON-NLS-2$ + {china, 'k', "12"}, //$NON-NLS-2$ + {0L, 'l', "8"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'l', "3"}, //$NON-NLS-2$ + {-1000L, 'l', "7"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'l', "1"}, //$NON-NLS-2$ + {paris, 'l', "12"}, //$NON-NLS-2$ + {china, 'l', "12"}, //$NON-NLS-2$ + {0L, 'm', "01"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'm', "08"}, //$NON-NLS-2$ + {-1000L, 'm', "01"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'm', "05"}, //$NON-NLS-2$ + {paris, 'm', "05"}, //$NON-NLS-2$ + {china, 'm', "05"}, //$NON-NLS-2$ + {0L, 'p', "\u5348\u524d"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'p', "\u5348\u5f8c"}, //$NON-NLS-2$ + {-1000L, 'p', "\u5348\u524d"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'p', "\u5348\u5f8c"}, //$NON-NLS-2$ + {paris, 'p', "\u5348\u5f8c"}, //$NON-NLS-2$ + {china, 'p', "\u5348\u5f8c"}, //$NON-NLS-2$ + {0L, 'r', "08:00:00 \u5348\u524d"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'r', "03:12:55 \u5348\u5f8c"}, //$NON-NLS-2$ + {-1000L, 'r', "07:59:59 \u5348\u524d"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'r', "01:59:07 \u5348\u5f8c"}, //$NON-NLS-2$ + {paris, 'r', "12:00:00 \u5348\u5f8c"}, //$NON-NLS-2$ + {china, 'r', "12:00:00 \u5348\u5f8c"}, //$NON-NLS-2$ + {0L, 's', "0"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 's', "9223372036854775"}, //$NON-NLS-2$ + {-1000L, 's', "-1"}, //$NON-NLS-2$ + {new Date(1147327147578L), 's', "1147327147"}, //$NON-NLS-2$ + {paris, 's', "1147082400"}, //$NON-NLS-2$ + {china, 's', "1147118400"}, //$NON-NLS-2$ + {0L, 'y', "70"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'y', "94"}, //$NON-NLS-2$ + {-1000L, 'y', "70"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'y', "06"}, //$NON-NLS-2$ + {paris, 'y', "06"}, //$NON-NLS-2$ + {china, 'y', "06"}, //$NON-NLS-2$ + {0L, 'z', "+0800"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'z', "+0800"}, //$NON-NLS-2$ + {-1000L, 'z', "+0800"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'z', "+0800"}, //$NON-NLS-2$ + {paris, 'z', "+0100"}, //$NON-NLS-2$ + {china, 'z', "-0800"}, //$NON-NLS-2$ + }; + + final int input = 0; + final int pattern = 1; + final int output = 2; + for (int i = 0; i < 90; i++) { + // go through legal conversion + String formatSpecifier = "%t" + lowerCaseGermanTriple[i][pattern]; //$NON-NLS-2$ + String formatSpecifierUpper = "%T" + lowerCaseGermanTriple[i][pattern]; //$NON-NLS-2$ + // test '%t' + f = new Formatter(Locale.GERMAN); + f.format(formatSpecifier, lowerCaseGermanTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$ + + " Argument: " + lowerCaseGermanTriple[i][pattern], //$NON-NLS-2$ + lowerCaseGermanTriple[i][output], f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format(Locale.FRANCE, formatSpecifier, lowerCaseFranceTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$ + + " Argument: " + lowerCaseFranceTriple[i][input], //$NON-NLS-2$ + lowerCaseFranceTriple[i][output], f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format(Locale.JAPAN, formatSpecifier, lowerCaseJapanTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$ + + " Argument: " + lowerCaseJapanTriple[i][input], //$NON-NLS-2$ + lowerCaseJapanTriple[i][output], f.toString()); + + // test '%T' + f = new Formatter(Locale.GERMAN); + f.format(formatSpecifierUpper, lowerCaseGermanTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$ + + " Argument: " + lowerCaseGermanTriple[i][input], //$NON-NLS-2$ + ((String)lowerCaseGermanTriple[i][output]) + .toUpperCase(Locale.US), f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format(Locale.FRANCE, formatSpecifierUpper, lowerCaseFranceTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$ + + " Argument: " + lowerCaseFranceTriple[i][input], //$NON-NLS-2$ + ((String)lowerCaseFranceTriple[i][output]) + .toUpperCase(Locale.US), f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format(Locale.JAPAN, formatSpecifierUpper, lowerCaseJapanTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$ + + " Argument: " + lowerCaseJapanTriple[i][input], //$NON-NLS-2$ + ((String)lowerCaseJapanTriple[i][output]) + .toUpperCase(Locale.US), f.toString()); + } + + final Object[][] upperCaseGermanTriple = { + {0L, 'A', "Donnerstag"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'A', "Sonntag"}, //$NON-NLS-2$ + {-1000L, 'A', "Donnerstag"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'A', "Donnerstag"}, //$NON-NLS-2$ + {paris, 'A', "Montag"}, //$NON-NLS-2$ + {china, 'A', "Montag"}, //$NON-NLS-2$ + {0L, 'B', "Januar"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'B', "August"}, //$NON-NLS-2$ + {-1000L, 'B', "Januar"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'B', "Mai"}, //$NON-NLS-2$ + {paris, 'B', "Mai"}, //$NON-NLS-2$ + {china, 'B', "Mai"}, //$NON-NLS-2$ + {0L, 'C', "19"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'C', "2922789"}, //$NON-NLS-2$ + {-1000L, 'C', "19"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'C', "20"}, //$NON-NLS-2$ + {paris, 'C', "20"}, //$NON-NLS-2$ + {china, 'C', "20"}, //$NON-NLS-2$ + {0L, 'D', "01/01/70"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'D', "08/17/94"}, //$NON-NLS-2$ + {-1000L, 'D', "01/01/70"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'D', "05/11/06"}, //$NON-NLS-2$ + {paris, 'D', "05/08/06"}, //$NON-NLS-2$ + {china, 'D', "05/08/06"}, //$NON-NLS-2$ + {0L, 'F', "1970-01-01"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'F', "292278994-08-17"}, //$NON-NLS-2$ + {-1000L, 'F', "1970-01-01"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'F', "2006-05-11"}, //$NON-NLS-2$ + {paris, 'F', "2006-05-08"}, //$NON-NLS-2$ + {china, 'F', "2006-05-08"}, //$NON-NLS-2$ + {0L, 'H', "08"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'H', "15"}, //$NON-NLS-2$ + {-1000L, 'H', "07"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'H', "13"}, //$NON-NLS-2$ + {paris, 'H', "12"}, //$NON-NLS-2$ + {china, 'H', "12"}, //$NON-NLS-2$ + {0L, 'I', "08"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'I', "03"}, //$NON-NLS-2$ + {-1000L, 'I', "07"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'I', "01"}, //$NON-NLS-2$ + {paris, 'I', "12"}, //$NON-NLS-2$ + {china, 'I', "12"}, //$NON-NLS-2$ + {0L, 'L', "000"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'L', "807"}, //$NON-NLS-2$ + {-1000L, 'L', "000"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'L', "578"}, //$NON-NLS-2$ + {paris, 'L', "453"}, //$NON-NLS-2$ + {china, 'L', "609"}, //$NON-NLS-2$ + {0L, 'M', "00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'M', "12"}, //$NON-NLS-2$ + {-1000L, 'M', "59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'M', "59"}, //$NON-NLS-2$ + {paris, 'M', "00"}, //$NON-NLS-2$ + {china, 'M', "00"}, //$NON-NLS-2$ + {0L, 'N', "000000000"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'N', "807000000"}, //$NON-NLS-2$ + {-1000L, 'N', "000000000"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'N', "578000000"}, //$NON-NLS-2$ + {paris, 'N', "609000000"}, //$NON-NLS-2$ + {china, 'N', "609000000"}, //$NON-NLS-2$ + {0L, 'Q', "0"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'Q', "9223372036854775807"}, //$NON-NLS-2$ + {-1000L, 'Q', "-1000"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'Q', "1147327147578"}, //$NON-NLS-2$ + {paris, 'Q', "1147082400453"}, //$NON-NLS-2$ + {china, 'Q', "1147118400609"}, //$NON-NLS-2$ + {0L, 'R', "08:00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'R', "15:12"}, //$NON-NLS-2$ + {-1000L, 'R', "07:59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'R', "13:59"}, //$NON-NLS-2$ + {paris, 'R', "12:00"}, //$NON-NLS-2$ + {china, 'R', "12:00"}, //$NON-NLS-2$ + {0L, 'S', "00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'S', "55"}, //$NON-NLS-2$ + {-1000L, 'S', "59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'S', "07"}, //$NON-NLS-2$ + {paris, 'S', "00"}, //$NON-NLS-2$ + {china, 'S', "00"}, //$NON-NLS-2$ + {0L, 'T', "08:00:00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'T', "15:12:55"}, //$NON-NLS-2$ + {-1000L, 'T', "07:59:59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'T', "13:59:07"}, //$NON-NLS-2$ + {paris, 'T', "12:00:00"}, //$NON-NLS-2$ + {china, 'T', "12:00:00"}, //$NON-NLS-2$ + {0L, 'Y', "1970"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'Y', "292278994"}, //$NON-NLS-2$ + {-1000L, 'Y', "1970"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'Y', "2006"}, //$NON-NLS-2$ + {paris, 'Y', "2006"}, //$NON-NLS-2$ + {china, 'Y', "2006"}, //$NON-NLS-2$ + {0L, 'Z', "CST"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'Z', "CST"}, //$NON-NLS-2$ + {-1000L, 'Z', "CST"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'Z', "CST"}, //$NON-NLS-2$ + {paris, 'Z', "CEST"}, //$NON-NLS-2$ + {china, 'Z', "GMT-08:00"}, //$NON-NLS-2$ + + }; + + final Object[][] upperCaseFranceTriple = { + {0L, 'A', "jeudi"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'A', "dimanche"}, //$NON-NLS-2$ + {-1000L, 'A', "jeudi"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'A', "jeudi"}, //$NON-NLS-2$ + {paris, 'A', "lundi"}, //$NON-NLS-2$ + {china, 'A', "lundi"}, //$NON-NLS-2$ + {0L, 'B', "janvier"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'B', "ao\u00fbt"}, //$NON-NLS-2$ + {-1000L, 'B', "janvier"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'B', "mai"}, //$NON-NLS-2$ + {paris, 'B', "mai"}, //$NON-NLS-2$ + {china, 'B', "mai"}, //$NON-NLS-2$ + {0L, 'C', "19"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'C', "2922789"}, //$NON-NLS-2$ + {-1000L, 'C', "19"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'C', "20"}, //$NON-NLS-2$ + {paris, 'C', "20"}, //$NON-NLS-2$ + {china, 'C', "20"}, //$NON-NLS-2$ + {0L, 'D', "01/01/70"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'D', "08/17/94"}, //$NON-NLS-2$ + {-1000L, 'D', "01/01/70"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'D', "05/11/06"}, //$NON-NLS-2$ + {paris, 'D', "05/08/06"}, //$NON-NLS-2$ + {china, 'D', "05/08/06"}, //$NON-NLS-2$ + {0L, 'F', "1970-01-01"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'F', "292278994-08-17"}, //$NON-NLS-2$ + {-1000L, 'F', "1970-01-01"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'F', "2006-05-11"}, //$NON-NLS-2$ + {paris, 'F', "2006-05-08"}, //$NON-NLS-2$ + {china, 'F', "2006-05-08"}, //$NON-NLS-2$ + {0L, 'H', "08"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'H', "15"}, //$NON-NLS-2$ + {-1000L, 'H', "07"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'H', "13"}, //$NON-NLS-2$ + {paris, 'H', "12"}, //$NON-NLS-2$ + {china, 'H', "12"}, //$NON-NLS-2$ + {0L, 'I', "08"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'I', "03"}, //$NON-NLS-2$ + {-1000L, 'I', "07"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'I', "01"}, //$NON-NLS-2$ + {paris, 'I', "12"}, //$NON-NLS-2$ + {china, 'I', "12"}, //$NON-NLS-2$ + {0L, 'L', "000"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'L', "807"}, //$NON-NLS-2$ + {-1000L, 'L', "000"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'L', "578"}, //$NON-NLS-2$ + {paris, 'L', "453"}, //$NON-NLS-2$ + {china, 'L', "609"}, //$NON-NLS-2$ + {0L, 'M', "00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'M', "12"}, //$NON-NLS-2$ + {-1000L, 'M', "59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'M', "59"}, //$NON-NLS-2$ + {paris, 'M', "00"}, //$NON-NLS-2$ + {china, 'M', "00"}, //$NON-NLS-2$ + {0L, 'N', "000000000"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'N', "807000000"}, //$NON-NLS-2$ + {-1000L, 'N', "000000000"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'N', "578000000"}, //$NON-NLS-2$ + {paris, 'N', "453000000"}, //$NON-NLS-2$ + {china, 'N', "468000000"}, //$NON-NLS-2$ + {0L, 'Q', "0"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'Q', "9223372036854775807"}, //$NON-NLS-2$ + {-1000L, 'Q', "-1000"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'Q', "1147327147578"}, //$NON-NLS-2$ + {paris, 'Q', "1147082400453"}, //$NON-NLS-2$ + {china, 'Q', "1147118400609"}, //$NON-NLS-2$ + {0L, 'R', "08:00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'R', "15:12"}, //$NON-NLS-2$ + {-1000L, 'R', "07:59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'R', "13:59"}, //$NON-NLS-2$ + {paris, 'R', "12:00"}, //$NON-NLS-2$ + {china, 'R', "12:00"}, //$NON-NLS-2$ + {0L, 'S', "00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'S', "55"}, //$NON-NLS-2$ + {-1000L, 'S', "59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'S', "07"}, //$NON-NLS-2$ + {paris, 'S', "00"}, //$NON-NLS-2$ + {china, 'S', "00"}, //$NON-NLS-2$ + {0L, 'T', "08:00:00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'T', "15:12:55"}, //$NON-NLS-2$ + {-1000L, 'T', "07:59:59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'T', "13:59:07"}, //$NON-NLS-2$ + {paris, 'T', "12:00:00"}, //$NON-NLS-2$ + {china, 'T', "12:00:00"}, //$NON-NLS-2$ + {0L, 'Y', "1970"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'Y', "292278994"}, //$NON-NLS-2$ + {-1000L, 'Y', "1970"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'Y', "2006"}, //$NON-NLS-2$ + {paris, 'Y', "2006"}, //$NON-NLS-2$ + {china, 'Y', "2006"}, //$NON-NLS-2$ + {0L, 'Z', "CST"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'Z', "CST"}, //$NON-NLS-2$ + {-1000L, 'Z', "CST"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'Z', "CST"}, //$NON-NLS-2$ + {paris, 'Z', "CEST"}, //$NON-NLS-2$ + {china, 'Z', "GMT-08:00"}, //$NON-NLS-2$ + + }; + + final Object[][] upperCaseJapanTriple = { + {0L, 'A', "\u6728\u66dc\u65e5"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'A', "\u65e5\u66dc\u65e5"}, //$NON-NLS-2$ + {-1000L, 'A', "\u6728\u66dc\u65e5"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'A', "\u6728\u66dc\u65e5"}, //$NON-NLS-2$ + {paris, 'A', "\u6708\u66dc\u65e5"}, //$NON-NLS-2$ + {china, 'A', "\u6708\u66dc\u65e5"}, //$NON-NLS-2$ + {0L, 'B', "1\u6708"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'B', "8\u6708"}, //$NON-NLS-2$ + {-1000L, 'B', "1\u6708"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'B', "5\u6708"}, //$NON-NLS-2$ + {paris, 'B', "5\u6708"}, //$NON-NLS-2$ + {china, 'B', "5\u6708"}, //$NON-NLS-2$ + {0L, 'C', "19"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'C', "2922789"}, //$NON-NLS-2$ + {-1000L, 'C', "19"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'C', "20"}, //$NON-NLS-2$ + {paris, 'C', "20"}, //$NON-NLS-2$ + {china, 'C', "20"}, //$NON-NLS-2$ + {0L, 'D', "01/01/70"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'D', "08/17/94"}, //$NON-NLS-2$ + {-1000L, 'D', "01/01/70"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'D', "05/11/06"}, //$NON-NLS-2$ + {paris, 'D', "05/08/06"}, //$NON-NLS-2$ + {china, 'D', "05/08/06"}, //$NON-NLS-2$ + {0L, 'F', "1970-01-01"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'F', "292278994-08-17"}, //$NON-NLS-2$ + {-1000L, 'F', "1970-01-01"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'F', "2006-05-11"}, //$NON-NLS-2$ + {paris, 'F', "2006-05-08"}, //$NON-NLS-2$ + {china, 'F', "2006-05-08"}, //$NON-NLS-2$ + {0L, 'H', "08"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'H', "15"}, //$NON-NLS-2$ + {-1000L, 'H', "07"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'H', "13"}, //$NON-NLS-2$ + {paris, 'H', "12"}, //$NON-NLS-2$ + {china, 'H', "12"}, //$NON-NLS-2$ + {0L, 'I', "08"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'I', "03"}, //$NON-NLS-2$ + {-1000L, 'I', "07"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'I', "01"}, //$NON-NLS-2$ + {paris, 'I', "12"}, //$NON-NLS-2$ + {china, 'I', "12"}, //$NON-NLS-2$ + {0L, 'L', "000"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'L', "807"}, //$NON-NLS-2$ + {-1000L, 'L', "000"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'L', "578"}, //$NON-NLS-2$ + {paris, 'L', "453"}, //$NON-NLS-2$ + {china, 'L', "609"}, //$NON-NLS-2$ + {0L, 'M', "00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'M', "12"}, //$NON-NLS-2$ + {-1000L, 'M', "59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'M', "59"}, //$NON-NLS-2$ + {paris, 'M', "00"}, //$NON-NLS-2$ + {china, 'M', "00"}, //$NON-NLS-2$ + {0L, 'N', "000000000"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'N', "807000000"}, //$NON-NLS-2$ + {-1000L, 'N', "000000000"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'N', "578000000"}, //$NON-NLS-2$ + {paris, 'N', "453000000"}, //$NON-NLS-2$ + {china, 'N', "468000000"}, //$NON-NLS-2$ + {0L, 'Q', "0"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'Q', "9223372036854775807"}, //$NON-NLS-2$ + {-1000L, 'Q', "-1000"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'Q', "1147327147578"}, //$NON-NLS-2$ + {paris, 'Q', "1147082400453"}, //$NON-NLS-2$ + {china, 'Q', "1147118400609"}, //$NON-NLS-2$ + {0L, 'R', "08:00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'R', "15:12"}, //$NON-NLS-2$ + {-1000L, 'R', "07:59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'R', "13:59"}, //$NON-NLS-2$ + {paris, 'R', "12:00"}, //$NON-NLS-2$ + {china, 'R', "12:00"}, //$NON-NLS-2$ + {0L, 'S', "00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'S', "55"}, //$NON-NLS-2$ + {-1000L, 'S', "59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'S', "07"}, //$NON-NLS-2$ + {paris, 'S', "00"}, //$NON-NLS-2$ + {china, 'S', "00"}, //$NON-NLS-2$ + {0L, 'T', "08:00:00"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'T', "15:12:55"}, //$NON-NLS-2$ + {-1000L, 'T', "07:59:59"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'T', "13:59:07"}, //$NON-NLS-2$ + {paris, 'T', "12:00:00"}, //$NON-NLS-2$ + {china, 'T', "12:00:00"}, //$NON-NLS-2$ + {0L, 'Y', "1970"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'Y', "292278994"}, //$NON-NLS-2$ + {-1000L, 'Y', "1970"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'Y', "2006"}, //$NON-NLS-2$ + {paris, 'Y', "2006"}, //$NON-NLS-2$ + {china, 'Y', "2006"}, //$NON-NLS-2$ + {0L, 'Z', "CST"}, //$NON-NLS-2$ + {Long.MAX_VALUE, 'Z', "CST"}, //$NON-NLS-2$ + {-1000L, 'Z', "CST"}, //$NON-NLS-2$ + {new Date(1147327147578L), 'Z', "CST"}, //$NON-NLS-2$ + {paris, 'Z', "CEST"}, //$NON-NLS-2$ + {china, 'Z', "GMT-08:00"}, //$NON-NLS-2$ + }; + + + for (int i = 0; i < 90; i++) { + String formatSpecifier = "%t" + upperCaseGermanTriple[i][pattern]; //$NON-NLS-2$ + String formatSpecifierUpper = "%T" + upperCaseGermanTriple[i][pattern]; //$NON-NLS-2$ + if ((Character)upperCaseGermanTriple[i][pattern] == 'N') { + // result can't be predicted on RI, so skip this test + continue; + } + // test '%t' + f = new Formatter(Locale.JAPAN); + f.format(formatSpecifier, upperCaseJapanTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$ + + " Argument: " + upperCaseJapanTriple[i][input], //$NON-NLS-2$ + upperCaseJapanTriple[i][output], f.toString()); + + f = new Formatter(Locale.JAPAN); + f.format(Locale.GERMAN, formatSpecifier, upperCaseGermanTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$ + + " Argument: " + upperCaseGermanTriple[i][input], //$NON-NLS-2$ + upperCaseGermanTriple[i][output], f.toString()); + + f = new Formatter(Locale.JAPAN); + f.format(Locale.FRANCE, formatSpecifier, upperCaseFranceTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$ + + " Argument: " + upperCaseFranceTriple[i][input], //$NON-NLS-2$ + upperCaseFranceTriple[i][output], f.toString()); + + // test '%T' + f = new Formatter(Locale.GERMAN); + f.format(formatSpecifierUpper, upperCaseGermanTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$ + + " Argument: " + upperCaseGermanTriple[i][input], //$NON-NLS-2$ + ((String)upperCaseGermanTriple[i][output]) + .toUpperCase(Locale.US), f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format(Locale.JAPAN, formatSpecifierUpper, upperCaseJapanTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$ + + " Argument: " + upperCaseJapanTriple[i][input], //$NON-NLS-2$ + ((String)upperCaseJapanTriple[i][output]) + .toUpperCase(Locale.US), f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format(Locale.FRANCE, formatSpecifierUpper, upperCaseFranceTriple[i][input]); + assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$ + + " Argument: " + upperCaseFranceTriple[i][input], //$NON-NLS-2$ + ((String)upperCaseFranceTriple[i][output]) + .toUpperCase(Locale.US), f.toString()); + } + + f = new Formatter(Locale.US); + f.format("%-10ta", now); //$NON-NLS-2$ + assertEquals("Thu ", f.toString()); //$NON-NLS-2$ + + f = new Formatter(Locale.US); + f.format("%10000000000000000000000000000000001ta", now); //$NON-NLS-2$ + assertEquals("Thu", f.toString().trim()); //$NON-NLS-2$ + } + + /** + * @tests java.util.Formatter#format(String, Object...) for null argment for + * Byte/Short/Integer/Long/BigInteger conversion + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongNullConversion() { + + Formatter f = new Formatter(Locale.FRANCE); + f.format("%d% + * MissingFormatWidthException > IllegalFormatFlagsException > + * IllegalFormatPrecisionException > IllegalFormatConversionException > + * FormatFlagsConversionMismatchException + * + */ + f = new Formatter(Locale.US); + try { + // compare IllegalFormatConversionException and + // FormatFlagsConversionMismatchException + f.format("%(o", false); + fail("should throw IllegalFormatConversionException"); + } catch (IllegalFormatConversionException e) { + // expected + } + + try { + // compare IllegalFormatPrecisionException and + // IllegalFormatConversionException + f.format("%.4o", false); + fail("should throw IllegalFormatPrecisionException"); + } catch (IllegalFormatPrecisionException e) { + // expected + } + + try { + // compare IllegalFormatFlagsException and + // IllegalFormatPrecisionException + f.format("%+ .4o", big); + fail("should throw IllegalFormatFlagsException"); + } catch (IllegalFormatFlagsException e) { + // expected + } + + try { + // compare MissingFormatWidthException and + // IllegalFormatFlagsException + f.format("%+ -o", big); + fail("should throw MissingFormatWidthException"); + } catch (MissingFormatWidthException e) { + // expected + } + + try { + // compare UnknownFormatConversionException and + // MissingFormatWidthException + f.format("%-O", big); + fail("should throw UnknownFormatConversionException"); + } catch (UnknownFormatConversionException e) { + // expected + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for Float/Double + * conversion type 'e' and 'E' + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionE() { + Formatter f = null; + final Object[][] tripleE = { + {0f, "%e", "0.000000e+00"}, + {0f, "%#.0e", "0.e+00"}, + {0f, "%#- (9.8e", " 0.00000000e+00"}, + {0f, "%#+0(8.4e", "+0.0000e+00"}, + {0f, "%-+(1.6e", "+0.000000e+00"}, + {0f, "% 0(12e", " 0.000000e+00"}, + + {101f, "%e", "1.010000e+02"}, + {101f, "%#.0e", "1.e+02"}, + {101f, "%#- (9.8e", " 1.01000000e+02"}, + {101f, "%#+0(8.4e", "+1.0100e+02"}, + {101f, "%-+(1.6e", "+1.010000e+02"}, + {101f, "% 0(12e", " 1.010000e+02"}, + + {1.f, "%e", "1.000000e+00"}, + {1.f, "%#.0e", "1.e+00"}, + {1.f, "%#- (9.8e", " 1.00000000e+00"}, + {1.f, "%#+0(8.4e", "+1.0000e+00"}, + {1.f, "%-+(1.6e", "+1.000000e+00"}, + {1.f, "% 0(12e", " 1.000000e+00"}, + + {-98f, "%e", "-9.800000e+01"}, + {-98f, "%#.0e", "-1.e+02"}, + {-98f, "%#- (9.8e", "(9.80000000e+01)"}, + {-98f, "%#+0(8.4e", "(9.8000e+01)"}, + {-98f, "%-+(1.6e", "(9.800000e+01)"}, + {-98f, "% 0(12e", "(9.800000e+01)"}, + + {1.23f, "%e", "1.230000e+00"}, + {1.23f, "%#.0e", "1.e+00"}, + {1.23f, "%#- (9.8e", " 1.23000002e+00"}, + {1.23f, "%#+0(8.4e", "+1.2300e+00"}, + {1.23f, "%-+(1.6e", "+1.230000e+00"}, + {1.23f, "% 0(12e", " 1.230000e+00"}, + + {34.1234567f, "%e", "3.412346e+01"}, + {34.1234567f, "%#.0e", "3.e+01"}, + {34.1234567f, "%#- (9.8e", " 3.41234550e+01"}, + {34.1234567f, "%#+0(8.4e", "+3.4123e+01"}, + {34.1234567f, "%-+(1.6e", "+3.412346e+01"}, + {34.1234567f, "% 0(12e", " 3.412346e+01"}, + + {-.12345f, "%e", "-1.234500e-01"}, + {-.12345f, "%#.0e", "-1.e-01"}, + {-.12345f, "%#- (9.8e", "(1.23450004e-01)"}, + {-.12345f, "%#+0(8.4e", "(1.2345e-01)"}, + {-.12345f, "%-+(1.6e", "(1.234500e-01)"}, + {-.12345f, "% 0(12e", "(1.234500e-01)"}, + + {-9876.1234567f, "%e", "-9.876123e+03"}, + {-9876.1234567f, "%#.0e", "-1.e+04"}, + {-9876.1234567f, "%#- (9.8e", "(9.87612305e+03)"}, + {-9876.1234567f, "%#+0(8.4e", "(9.8761e+03)"}, + {-9876.1234567f, "%-+(1.6e", "(9.876123e+03)"}, + {-9876.1234567f, "% 0(12e", "(9.876123e+03)"}, + + {Float.MAX_VALUE, "%e", "3.402823e+38"}, + {Float.MAX_VALUE, "%#.0e", "3.e+38"}, + {Float.MAX_VALUE, "%#- (9.8e", " 3.40282347e+38"}, + {Float.MAX_VALUE, "%#+0(8.4e", "+3.4028e+38"}, + {Float.MAX_VALUE, "%-+(1.6e", "+3.402823e+38"}, + {Float.MAX_VALUE, "% 0(12e", " 3.402823e+38"}, + + {Float.MIN_VALUE, "%e", "1.401298e-45"}, + {Float.MIN_VALUE, "%#.0e", "1.e-45"}, + {Float.MIN_VALUE, "%#- (9.8e", " 1.40129846e-45"}, + {Float.MIN_VALUE, "%#+0(8.4e", "+1.4013e-45"}, + {Float.MIN_VALUE, "%-+(1.6e", "+1.401298e-45"}, + {Float.MIN_VALUE, "% 0(12e", " 1.401298e-45"}, + + {Float.NaN, "%e", "NaN"}, + {Float.NaN, "%#.0e", "NaN"}, + {Float.NaN, "%#- (9.8e", "NaN "}, + {Float.NaN, "%#+0(8.4e", " NaN"}, + {Float.NaN, "%-+(1.6e", "NaN"}, + {Float.NaN, "% 0(12e", " NaN"}, + + + {Float.NEGATIVE_INFINITY, "%e", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%#.0e", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%#- (9.8e", "(Infinity)"}, + {Float.NEGATIVE_INFINITY, "%#+0(8.4e", "(Infinity)"}, + {Float.NEGATIVE_INFINITY, "%-+(1.6e", "(Infinity)"}, + {Float.NEGATIVE_INFINITY, "% 0(12e", " (Infinity)"}, + + {Float.NEGATIVE_INFINITY, "%e", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%#.0e", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%#- (9.8e", "(Infinity)"}, + {Float.NEGATIVE_INFINITY, "%#+0(8.4e", "(Infinity)"}, + {Float.NEGATIVE_INFINITY, "%-+(1.6e", "(Infinity)"}, + {Float.NEGATIVE_INFINITY, "% 0(12e", " (Infinity)"}, + + {0d, "%e", "0.000000e+00"}, + {0d, "%#.0e", "0.e+00"}, + {0d, "%#- (9.8e", " 0.00000000e+00"}, + {0d, "%#+0(8.4e", "+0.0000e+00"}, + {0d, "%-+(1.6e", "+0.000000e+00"}, + {0d, "% 0(12e", " 0.000000e+00"}, + + {1d, "%e", "1.000000e+00"}, + {1d, "%#.0e", "1.e+00"}, + {1d, "%#- (9.8e", " 1.00000000e+00"}, + {1d, "%#+0(8.4e", "+1.0000e+00"}, + {1d, "%-+(1.6e", "+1.000000e+00"}, + {1d, "% 0(12e", " 1.000000e+00"}, + + {-1d, "%e", "-1.000000e+00"}, + {-1d, "%#.0e", "-1.e+00"}, + {-1d, "%#- (9.8e", "(1.00000000e+00)"}, + {-1d, "%#+0(8.4e", "(1.0000e+00)"}, + {-1d, "%-+(1.6e", "(1.000000e+00)"}, + {-1d, "% 0(12e", "(1.000000e+00)"}, + + + {.00000001d, "%e", "1.000000e-08"}, + {.00000001d, "%#.0e", "1.e-08"}, + {.00000001d, "%#- (9.8e", " 1.00000000e-08"}, + {.00000001d, "%#+0(8.4e", "+1.0000e-08"}, + {.00000001d, "%-+(1.6e", "+1.000000e-08"}, + {.00000001d, "% 0(12e", " 1.000000e-08"}, + + {9122.10d, "%e", "9.122100e+03"}, + {9122.10d, "%#.0e", "9.e+03"}, + {9122.10d, "%#- (9.8e", " 9.12210000e+03"}, + {9122.10d, "%#+0(8.4e", "+9.1221e+03"}, + {9122.10d, "%-+(1.6e", "+9.122100e+03"}, + {9122.10d, "% 0(12e", " 9.122100e+03"}, + + {0.1d, "%e", "1.000000e-01"}, + {0.1d, "%#.0e", "1.e-01"}, + {0.1d, "%#- (9.8e", " 1.00000000e-01"}, + {0.1d, "%#+0(8.4e", "+1.0000e-01"}, + {0.1d, "%-+(1.6e", "+1.000000e-01"}, + {0.1d, "% 0(12e", " 1.000000e-01"}, + + {-2.d, "%e", "-2.000000e+00"}, + {-2.d, "%#.0e", "-2.e+00"}, + {-2.d, "%#- (9.8e", "(2.00000000e+00)"}, + {-2.d, "%#+0(8.4e", "(2.0000e+00)"}, + {-2.d, "%-+(1.6e", "(2.000000e+00)"}, + {-2.d, "% 0(12e", "(2.000000e+00)"}, + + {-.39d, "%e", "-3.900000e-01"}, + {-.39d, "%#.0e", "-4.e-01"}, + {-.39d, "%#- (9.8e", "(3.90000000e-01)"}, + {-.39d, "%#+0(8.4e", "(3.9000e-01)"}, + {-.39d, "%-+(1.6e", "(3.900000e-01)"}, + {-.39d, "% 0(12e", "(3.900000e-01)"}, + + {-1234567890.012345678d, "%e", "-1.234568e+09"}, + {-1234567890.012345678d, "%#.0e", "-1.e+09"}, + {-1234567890.012345678d, "%#- (9.8e", "(1.23456789e+09)"}, + {-1234567890.012345678d, "%#+0(8.4e", "(1.2346e+09)"}, + {-1234567890.012345678d, "%-+(1.6e", "(1.234568e+09)"}, + {-1234567890.012345678d, "% 0(12e", "(1.234568e+09)"}, + + {Double.MAX_VALUE, "%e", "1.797693e+308"}, + {Double.MAX_VALUE, "%#.0e", "2.e+308"}, + {Double.MAX_VALUE, "%#- (9.8e", " 1.79769313e+308"}, + {Double.MAX_VALUE, "%#+0(8.4e", "+1.7977e+308"}, + {Double.MAX_VALUE, "%-+(1.6e", "+1.797693e+308"}, + {Double.MAX_VALUE, "% 0(12e", " 1.797693e+308"}, + + {Double.MIN_VALUE, "%e", "4.900000e-324"}, + {Double.MIN_VALUE, "%#.0e", "5.e-324"}, + {Double.MIN_VALUE, "%#- (9.8e", " 4.90000000e-324"}, + {Double.MIN_VALUE, "%#+0(8.4e", "+4.9000e-324"}, + {Double.MIN_VALUE, "%-+(1.6e", "+4.900000e-324"}, + {Double.MIN_VALUE, "% 0(12e", " 4.900000e-324"}, + + {Double.NaN, "%e", "NaN"}, + {Double.NaN, "%#.0e", "NaN"}, + {Double.NaN, "%#- (9.8e", "NaN "}, + {Double.NaN, "%#+0(8.4e", " NaN"}, + {Double.NaN, "%-+(1.6e", "NaN"}, + {Double.NaN, "% 0(12e", " NaN"}, + + {Double.NEGATIVE_INFINITY, "%e", "-Infinity"}, + {Double.NEGATIVE_INFINITY, "%#.0e", "-Infinity"}, + {Double.NEGATIVE_INFINITY, "%#- (9.8e", "(Infinity)"}, + {Double.NEGATIVE_INFINITY, "%#+0(8.4e", "(Infinity)"}, + {Double.NEGATIVE_INFINITY, "%-+(1.6e", "(Infinity)"}, + {Double.NEGATIVE_INFINITY, "% 0(12e", " (Infinity)"}, + + {Double.POSITIVE_INFINITY, "%e", "Infinity"}, + {Double.POSITIVE_INFINITY, "%#.0e", "Infinity"}, + {Double.POSITIVE_INFINITY, "%#- (9.8e", " Infinity"}, + {Double.POSITIVE_INFINITY, "%#+0(8.4e", "+Infinity"}, + {Double.POSITIVE_INFINITY, "%-+(1.6e", "+Infinity"}, + {Double.POSITIVE_INFINITY, "% 0(12e", " Infinity"}, + }; + final int input = 0; + final int pattern = 1; + final int output = 2; + for (int i = 0; i < tripleE.length; i++) { + f = new Formatter(Locale.US); + f.format((String)tripleE[i][pattern], tripleE[i][input]); + assertEquals("triple[" + i + "]:" + tripleE[i][input] + ",pattern[" + + i + "]:" + tripleE[i][pattern], + tripleE[i][output], f.toString()); + + // test for conversion type 'E' + f = new Formatter(Locale.US); + f.format(((String)tripleE[i][pattern]).toUpperCase(), tripleE[i][input]); + assertEquals("triple[" + i + "]:" + tripleE[i][input] + ",pattern[" + + i + "]:" + tripleE[i][pattern], ((String)tripleE[i][output]) + .toUpperCase(Locale.UK), f.toString()); + } + + f = new Formatter(Locale.GERMAN); + f.format("%e", 1001f); + /* + * fail on RI, spec says 'e' requires the output to be formatted in + * general scientific notation and the localization algorithm is + * applied. But RI format this case to 1.001000e+03, which does not + * conform to the German Locale + */ + assertEquals("1,001000e+03", f.toString()); + } + + /** + * @tests java.util.Formatter#format(String, Object...) for Float/Double + * conversion type 'g' and 'G' + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionG() { + Formatter f = null; + final Object[][] tripleG = { + {1001f, "%g", "1001.00"}, + {1001f, "%- (,9.8g", " 1,001.0000"}, + {1001f, "%+0(,8.4g", "+001,001"}, + {1001f, "%-+(,1.6g", "+1,001.00"}, + {1001f, "% 0(,12.0g", " 0000001e+03"}, + + {1.f, "%g", "1.00000"}, + {1.f, "%- (,9.8g", " 1.0000000"}, + {1.f, "%+0(,8.4g", "+001.000"}, + {1.f, "%-+(,1.6g", "+1.00000"}, + {1.f, "% 0(,12.0g", " 00000000001"}, + + {-98f, "%g", "-98.0000"}, + {-98f, "%- (,9.8g", "(98.000000)"}, + {-98f, "%+0(,8.4g", "(098.00)"}, + {-98f, "%-+(,1.6g", "(98.0000)"}, + {-98f, "% 0(,12.0g", "(000001e+02)"}, + + {0.000001f, "%g", "1.00000e-06"}, + {0.000001f, "%- (,9.8g", " 1.0000000e-06"}, + {0.000001f, "%+0(,8.4g", "+1.000e-06"}, + {0.000001f, "%-+(,1.6g", "+1.00000e-06"}, + {0.000001f, "% 0(,12.0g", " 0000001e-06"}, + + {345.1234567f, "%g", "345.123"}, + {345.1234567f, "%- (,9.8g", " 345.12344"}, + {345.1234567f, "%+0(,8.4g", "+00345.1"}, + {345.1234567f, "%-+(,1.6g", "+345.123"}, + {345.1234567f, "% 0(,12.0g", " 0000003e+02"}, + + {-.00000012345f, "%g", "-1.23450e-07"}, + {-.00000012345f, "%- (,9.8g", "(1.2344999e-07)"}, + {-.00000012345f, "%+0(,8.4g", "(1.234e-07)"}, + {-.00000012345f, "%-+(,1.6g", "(1.23450e-07)"}, + {-.00000012345f, "% 0(,12.0g", "(000001e-07)"}, + + {-987.1234567f, "%g", "-987.123"}, + {-987.1234567f, "%- (,9.8g", "(987.12347)"}, + {-987.1234567f, "%+0(,8.4g", "(0987.1)"}, + {-987.1234567f, "%-+(,1.6g", "(987.123)"}, + {-987.1234567f, "% 0(,12.0g", "(000001e+03)"}, + + {Float.MAX_VALUE, "%g", "3.40282e+38"}, + {Float.MAX_VALUE, "%- (,9.8g", " 3.4028235e+38"}, + {Float.MAX_VALUE, "%+0(,8.4g", "+3.403e+38"}, + {Float.MAX_VALUE, "%-+(,1.6g", "+3.40282e+38"}, + {Float.MAX_VALUE, "% 0(,12.0g", " 0000003e+38"}, + + {Float.MIN_VALUE, "%g", "1.40130e-45"}, + {Float.MIN_VALUE, "%- (,9.8g", " 1.4012985e-45"}, + {Float.MIN_VALUE, "%+0(,8.4g", "+1.401e-45"}, + {Float.MIN_VALUE, "%-+(,1.6g", "+1.40130e-45"}, + {Float.MIN_VALUE, "% 0(,12.0g", " 0000001e-45"}, + + {Float.NaN, "%g", "NaN"}, + {Float.NaN, "%- (,9.8g", "NaN "}, + {Float.NaN, "%+0(,8.4g", " NaN"}, + {Float.NaN, "%-+(,1.6g", "NaN"}, + {Float.NaN, "% 0(,12.0g", " NaN"}, + + {Float.NEGATIVE_INFINITY, "%g", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%- (,9.8g", "(Infinity)"}, + {Float.NEGATIVE_INFINITY, "%+0(,8.4g", "(Infinity)"}, + {Float.NEGATIVE_INFINITY, "%-+(,1.6g", "(Infinity)"}, + {Float.NEGATIVE_INFINITY, "% 0(,12.0g", " (Infinity)"}, + + {Float.POSITIVE_INFINITY, "%g", "Infinity"}, + {Float.POSITIVE_INFINITY, "%- (,9.8g", " Infinity"}, + {Float.POSITIVE_INFINITY, "%+0(,8.4g", "+Infinity"}, + {Float.POSITIVE_INFINITY, "%-+(,1.6g", "+Infinity"}, + {Float.POSITIVE_INFINITY, "% 0(,12.0g", " Infinity"}, + + {1d, "%g", "1.00000"}, + {1d, "%- (,9.8g", " 1.0000000"}, + {1d, "%+0(,8.4g", "+001.000"}, + {1d, "%-+(,1.6g", "+1.00000"}, + {1d, "% 0(,12.0g", " 00000000001"}, + + {-1d, "%g", "-1.00000"}, + {-1d, "%- (,9.8g", "(1.0000000)"}, + {-1d, "%+0(,8.4g", "(01.000)"}, + {-1d, "%-+(,1.6g", "(1.00000)"}, + {-1d, "% 0(,12.0g", "(0000000001)"}, + + {.00000001d, "%g", "1.00000e-08"}, + {.00000001d, "%- (,9.8g", " 1.0000000e-08"}, + {.00000001d, "%+0(,8.4g", "+1.000e-08"}, + {.00000001d, "%-+(,1.6g", "+1.00000e-08"}, + {.00000001d, "% 0(,12.0g", " 0000001e-08"}, + + {1912.10d, "%g", "1912.10"}, + {1912.10d, "%- (,9.8g", " 1,912.1000"}, + {1912.10d, "%+0(,8.4g", "+001,912"}, + {1912.10d, "%-+(,1.6g", "+1,912.10"}, + {1912.10d, "% 0(,12.0g", " 0000002e+03"}, + + {0.1d, "%g", "0.100000"}, + {0.1d, "%- (,9.8g", " 0.10000000"}, + {0.1d, "%+0(,8.4g", "+00.1000"}, + {0.1d, "%-+(,1.6g", "+0.100000"}, + {0.1d, "% 0(,12.0g", " 000000000.1"}, + + {-2.d, "%g", "-2.00000"}, + {-2.d, "%- (,9.8g", "(2.0000000)"}, + {-2.d, "%+0(,8.4g", "(02.000)"}, + {-2.d, "%-+(,1.6g", "(2.00000)"}, + {-2.d, "% 0(,12.0g", "(0000000002)"}, + + {-.00039d, "%g", "-0.000390000"}, + {-.00039d, "%- (,9.8g", "(0.00039000000)"}, + {-.00039d, "%+0(,8.4g", "(0.0003900)"}, + {-.00039d, "%-+(,1.6g", "(0.000390000)"}, + {-.00039d, "% 0(,12.0g", "(00000.0004)"}, + + {-1234567890.012345678d, "%g", "-1.23457e+09"}, + {-1234567890.012345678d, "%- (,9.8g", "(1.2345679e+09)"}, + {-1234567890.012345678d, "%+0(,8.4g", "(1.235e+09)"}, + {-1234567890.012345678d, "%-+(,1.6g", "(1.23457e+09)"}, + {-1234567890.012345678d, "% 0(,12.0g", "(000001e+09)"}, + + {Double.MAX_VALUE, "%g", "1.79769e+308"}, + {Double.MAX_VALUE, "%- (,9.8g", " 1.7976931e+308"}, + {Double.MAX_VALUE, "%+0(,8.4g", "+1.798e+308"}, + {Double.MAX_VALUE, "%-+(,1.6g", "+1.79769e+308"}, + {Double.MAX_VALUE, "% 0(,12.0g", " 000002e+308"}, + + {Double.MIN_VALUE, "%g", "4.90000e-324"}, + {Double.MIN_VALUE, "%- (,9.8g", " 4.9000000e-324"}, + {Double.MIN_VALUE, "%+0(,8.4g", "+4.900e-324"}, + {Double.MIN_VALUE, "%-+(,1.6g", "+4.90000e-324"}, + {Double.MIN_VALUE, "% 0(,12.0g", " 000005e-324"}, + + {Double.NaN, "%g", "NaN"}, + {Double.NaN, "%- (,9.8g", "NaN "}, + {Double.NaN, "%+0(,8.4g", " NaN"}, + {Double.NaN, "%-+(,1.6g", "NaN"}, + {Double.NaN, "% 0(,12.0g", " NaN"}, + + {Double.NEGATIVE_INFINITY, "%g", "-Infinity"}, + {Double.NEGATIVE_INFINITY, "%- (,9.8g", "(Infinity)"}, + {Double.NEGATIVE_INFINITY, "%+0(,8.4g", "(Infinity)"}, + {Double.NEGATIVE_INFINITY, "%-+(,1.6g", "(Infinity)"}, + {Double.NEGATIVE_INFINITY, "% 0(,12.0g", " (Infinity)"}, + + {Double.POSITIVE_INFINITY, "%g", "Infinity"}, + {Double.POSITIVE_INFINITY, "%- (,9.8g", " Infinity"}, + {Double.POSITIVE_INFINITY, "%+0(,8.4g", "+Infinity"}, + {Double.POSITIVE_INFINITY, "%-+(,1.6g", "+Infinity"}, + {Double.POSITIVE_INFINITY, "% 0(,12.0g", " Infinity"}, + + }; + final int input = 0; + final int pattern = 1; + final int output = 2; + for (int i = 0; i < tripleG.length; i++) { + + f = new Formatter(Locale.US); + f.format((String)tripleG[i][pattern], tripleG[i][input]); + assertEquals("triple[" + i + "]:" + tripleG[i][input] + ",pattern[" + + i + "]:" + tripleG[i][pattern], + tripleG[i][output], f.toString()); + + // test for conversion type 'G' + f = new Formatter(Locale.US); + f.format(((String)tripleG[i][pattern]).toUpperCase(), tripleG[i][input]); + assertEquals("triple[" + i + "]:" + tripleG[i][input] + ",pattern[" + + i + "]:" + tripleG[i][pattern], ((String)tripleG[i][output]) + .toUpperCase(Locale.UK), f.toString()); + } + + f = new Formatter(Locale.US); + f.format("%.5g", 0f); + assertEquals("0.0000", f.toString()); + + f = new Formatter(Locale.US); + f.format("%.0g", 0f); + /* + * fail on RI, spec says if the precision is 0, then it is taken to be + * 1. but RI throws ArrayIndexOutOfBoundsException. + */ + assertEquals("0", f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format("%g", 1001f); + /* + * fail on RI, spec says 'g' requires the output to be formatted in + * general scientific notation and the localization algorithm is + * applied. But RI format this case to 1001.00, which does not conform + * to the German Locale + */ + assertEquals("1001,00", f.toString()); + } + + /** + * @tests java.util.Formatter#format(String, Object...) for Float/Double + * conversion type 'g' and 'G' overflow + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionG_Overflow() { + Formatter f = new Formatter(); + f.format("%g", 999999.5); + assertEquals("1.00000e+06", f.toString()); + + f = new Formatter(); + f.format("%g", 99999.5); + assertEquals("99999.5", f.toString()); + + f = new Formatter(); + f.format("%.4g", 99.95); + assertEquals("99.95", f.toString()); + + f = new Formatter(); + f.format("%g", 99.95); + assertEquals("99.9500", f.toString()); + + f = new Formatter(); + f.format("%g", 0.9); + assertEquals("0.900000", f.toString()); + + f = new Formatter(); + f.format("%.0g", 0.000095); + assertEquals("0.0001", f.toString()); + + f = new Formatter(); + f.format("%g", 0.0999999); + assertEquals("0.0999999", f.toString()); + + f = new Formatter(); + f.format("%g", 0.00009); + assertEquals("9.00000e-05", f.toString()); + } + + /** + * @tests java.util.Formatter#format(String, Object...) for Float/Double + * conversion type 'f' + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionF() { + Formatter f = null; + + final Object[][] tripleF = { + {0f, "%f", "0,000000"}, + {0f, "%#.3f", "0,000"}, + {0f, "%,5f", "0,000000"}, + {0f, "%- (12.0f", " 0 "}, + {0f, "%#+0(1.6f", "+0,000000"}, + {0f, "%-+(8.4f", "+0,0000 "}, + {0f, "% 0#(9.8f", " 0,00000000"}, + + {1234f, "%f", "1234,000000"}, + {1234f, "%#.3f", "1234,000"}, + {1234f, "%,5f", "1.234,000000"}, + {1234f, "%- (12.0f", " 1234 "}, + {1234f, "%#+0(1.6f", "+1234,000000"}, + {1234f, "%-+(8.4f", "+1234,0000"}, + {1234f, "% 0#(9.8f", " 1234,00000000"}, + + {1.f, "%f", "1,000000"}, + {1.f, "%#.3f", "1,000"}, + {1.f, "%,5f", "1,000000"}, + {1.f, "%- (12.0f", " 1 "}, + {1.f, "%#+0(1.6f", "+1,000000"}, + {1.f, "%-+(8.4f", "+1,0000 "}, + {1.f, "% 0#(9.8f", " 1,00000000"}, + + {-98f, "%f", "-98,000000"}, + {-98f, "%#.3f", "-98,000"}, + {-98f, "%,5f", "-98,000000"}, + {-98f, "%- (12.0f", "(98) "}, + {-98f, "%#+0(1.6f", "(98,000000)"}, + {-98f, "%-+(8.4f", "(98,0000)"}, + {-98f, "% 0#(9.8f", "(98,00000000)"}, + + {0.000001f, "%f", "0,000001"}, + {0.000001f, "%#.3f", "0,000"}, + {0.000001f, "%,5f", "0,000001"}, + {0.000001f, "%- (12.0f", " 0 "}, + {0.000001f, "%#+0(1.6f", "+0,000001"}, + {0.000001f, "%-+(8.4f", "+0,0000 "}, + {0.000001f, "% 0#(9.8f", " 0,00000100"}, + + {345.1234567f, "%f", "345,123444"}, + {345.1234567f, "%#.3f", "345,123"}, + {345.1234567f, "%,5f", "345,123444"}, + {345.1234567f, "%- (12.0f", " 345 "}, + {345.1234567f, "%#+0(1.6f", "+345,123444"}, + {345.1234567f, "%-+(8.4f", "+345,1234"}, + {345.1234567f, "% 0#(9.8f", " 345,12344360"}, + + {-.00000012345f, "%f", "-0,000000"}, + {-.00000012345f, "%#.3f", "-0,000"}, + {-.00000012345f, "%,5f", "-0,000000"}, + {-.00000012345f, "%- (12.0f", "(0) "}, + {-.00000012345f, "%#+0(1.6f", "(0,000000)"}, + {-.00000012345f, "%-+(8.4f", "(0,0000)"}, + {-.00000012345f, "% 0#(9.8f", "(0,00000012)"}, + + {-987654321.1234567f, "%f", "-987654336,000000"}, + {-987654321.1234567f, "%#.3f", "-987654336,000"}, + {-987654321.1234567f, "%,5f", "-987.654.336,000000"}, + {-987654321.1234567f, "%- (12.0f", "(987654336) "}, + {-987654321.1234567f, "%#+0(1.6f", "(987654336,000000)"}, + {-987654321.1234567f, "%-+(8.4f", "(987654336,0000)"}, + {-987654321.1234567f, "% 0#(9.8f", "(987654336,00000000)"}, + + {Float.MAX_VALUE, "%f", "340282346638528860000000000000000000000,000000"}, + {Float.MAX_VALUE, "%#.3f", "340282346638528860000000000000000000000,000"}, + {Float.MAX_VALUE, "%,5f", "340.282.346.638.528.860.000.000.000.000.000.000.000,000000"}, + {Float.MAX_VALUE, "%- (12.0f", " 340282346638528860000000000000000000000"}, + {Float.MAX_VALUE, "%#+0(1.6f", "+340282346638528860000000000000000000000,000000"}, + {Float.MAX_VALUE, "%-+(8.4f", "+340282346638528860000000000000000000000,0000"}, + {Float.MAX_VALUE, "% 0#(9.8f", " 340282346638528860000000000000000000000,00000000"}, + + {Float.MIN_VALUE, "%f", "0,000000"}, + {Float.MIN_VALUE, "%#.3f", "0,000"}, + {Float.MIN_VALUE, "%,5f", "0,000000"}, + {Float.MIN_VALUE, "%- (12.0f", " 0 "}, + {Float.MIN_VALUE, "%#+0(1.6f", "+0,000000"}, + {Float.MIN_VALUE, "%-+(8.4f", "+0,0000 "}, + {Float.MIN_VALUE, "% 0#(9.8f", " 0,00000000"}, + + {Float.NaN, "%f", "NaN"}, + {Float.NaN, "%#.3f", "NaN"}, + {Float.NaN, "%,5f", " NaN"}, + {Float.NaN, "%- (12.0f", "NaN "}, + {Float.NaN, "%#+0(1.6f", "NaN"}, + {Float.NaN, "%-+(8.4f", "NaN "}, + {Float.NaN, "% 0#(9.8f", " NaN"}, + + {Float.NEGATIVE_INFINITY, "%f", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%#.3f", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%,5f", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%- (12.0f", "(Infinity) "}, + {Float.NEGATIVE_INFINITY, "%#+0(1.6f", "(Infinity)"}, + {Float.NEGATIVE_INFINITY, "%-+(8.4f", "(Infinity)"}, + {Float.NEGATIVE_INFINITY, "% 0#(9.8f", "(Infinity)"}, + + {Float.POSITIVE_INFINITY, "%f", "Infinity"}, + {Float.POSITIVE_INFINITY, "%#.3f", "Infinity"}, + {Float.POSITIVE_INFINITY, "%,5f", "Infinity"}, + {Float.POSITIVE_INFINITY, "%- (12.0f", " Infinity "}, + {Float.POSITIVE_INFINITY, "%#+0(1.6f", "+Infinity"}, + {Float.POSITIVE_INFINITY, "%-+(8.4f", "+Infinity"}, + {Float.POSITIVE_INFINITY, "% 0#(9.8f", " Infinity"}, + + + {0d, "%f", "0,000000"}, + {0d, "%#.3f", "0,000"}, + {0d, "%,5f", "0,000000"}, + {0d, "%- (12.0f", " 0 "}, + {0d, "%#+0(1.6f", "+0,000000"}, + {0d, "%-+(8.4f", "+0,0000 "}, + {0d, "% 0#(9.8f", " 0,00000000"}, + + {1d, "%f", "1,000000"}, + {1d, "%#.3f", "1,000"}, + {1d, "%,5f", "1,000000"}, + {1d, "%- (12.0f", " 1 "}, + {1d, "%#+0(1.6f", "+1,000000"}, + {1d, "%-+(8.4f", "+1,0000 "}, + {1d, "% 0#(9.8f", " 1,00000000"}, + + {-1d, "%f", "-1,000000"}, + {-1d, "%#.3f", "-1,000"}, + {-1d, "%,5f", "-1,000000"}, + {-1d, "%- (12.0f", "(1) "}, + {-1d, "%#+0(1.6f", "(1,000000)"}, + {-1d, "%-+(8.4f", "(1,0000)"}, + {-1d, "% 0#(9.8f", "(1,00000000)"}, + + {.00000001d, "%f", "0,000000"}, + {.00000001d, "%#.3f", "0,000"}, + {.00000001d, "%,5f", "0,000000"}, + {.00000001d, "%- (12.0f", " 0 "}, + {.00000001d, "%#+0(1.6f", "+0,000000"}, + {.00000001d, "%-+(8.4f", "+0,0000 "}, + {.00000001d, "% 0#(9.8f", " 0,00000001"}, + + {1000.10d, "%f", "1000,100000"}, + {1000.10d, "%#.3f", "1000,100"}, + {1000.10d, "%,5f", "1.000,100000"}, + {1000.10d, "%- (12.0f", " 1000 "}, + {1000.10d, "%#+0(1.6f", "+1000,100000"}, + {1000.10d, "%-+(8.4f", "+1000,1000"}, + {1000.10d, "% 0#(9.8f", " 1000,10000000"}, + + {0.1d, "%f", "0,100000"}, + {0.1d, "%#.3f", "0,100"}, + {0.1d, "%,5f", "0,100000"}, + {0.1d, "%- (12.0f", " 0 "}, + {0.1d, "%#+0(1.6f", "+0,100000"}, + {0.1d, "%-+(8.4f", "+0,1000 "}, + {0.1d, "% 0#(9.8f", " 0,10000000"}, + + {-2.d, "%f", "-2,000000"}, + {-2.d, "%#.3f", "-2,000"}, + {-2.d, "%,5f", "-2,000000"}, + {-2.d, "%- (12.0f", "(2) "}, + {-2.d, "%#+0(1.6f", "(2,000000)"}, + {-2.d, "%-+(8.4f", "(2,0000)"}, + {-2.d, "% 0#(9.8f", "(2,00000000)"}, + + {-.00009d, "%f", "-0,000090"}, + {-.00009d, "%#.3f", "-0,000"}, + {-.00009d, "%,5f", "-0,000090"}, + {-.00009d, "%- (12.0f", "(0) "}, + {-.00009d, "%#+0(1.6f", "(0,000090)"}, + {-.00009d, "%-+(8.4f", "(0,0001)"}, + {-.00009d, "% 0#(9.8f", "(0,00009000)"}, + + {-1234567890.012345678d, "%f", "-1234567890,012346"}, + {-1234567890.012345678d, "%#.3f", "-1234567890,012"}, + {-1234567890.012345678d, "%,5f", "-1.234.567.890,012346"}, + {-1234567890.012345678d, "%- (12.0f", "(1234567890)"}, + {-1234567890.012345678d, "%#+0(1.6f", "(1234567890,012346)"}, + {-1234567890.012345678d, "%-+(8.4f", "(1234567890,0123)"}, + {-1234567890.012345678d, "% 0#(9.8f", "(1234567890,01234580)"}, + + {Double.MAX_VALUE, "%f", "179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,000000"}, + {Double.MAX_VALUE, "%#.3f", "179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,000"}, + {Double.MAX_VALUE, "%,5f", "179.769.313.486.231.570.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000,000000"}, + {Double.MAX_VALUE, "%- (12.0f", " 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}, + {Double.MAX_VALUE, "%#+0(1.6f", "+179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,000000"}, + {Double.MAX_VALUE, "%-+(8.4f", "+179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,0000"}, + {Double.MAX_VALUE, "% 0#(9.8f", " 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,00000000"}, + + {Double.MIN_VALUE, "%f", "0,000000"}, + {Double.MIN_VALUE, "%#.3f", "0,000"}, + {Double.MIN_VALUE, "%,5f", "0,000000"}, + {Double.MIN_VALUE, "%- (12.0f", " 0 "}, + {Double.MIN_VALUE, "%#+0(1.6f", "+0,000000"}, + {Double.MIN_VALUE, "%-+(8.4f", "+0,0000 "}, + {Double.MIN_VALUE, "% 0#(9.8f", " 0,00000000"}, + + {Double.NaN, "%f", "NaN"}, + {Double.NaN, "%#.3f", "NaN"}, + {Double.NaN, "%,5f", " NaN"}, + {Double.NaN, "%- (12.0f", "NaN "}, + {Double.NaN, "%#+0(1.6f", "NaN"}, + {Double.NaN, "%-+(8.4f", "NaN "}, + {Double.NaN, "% 0#(9.8f", " NaN"}, + + {Double.POSITIVE_INFINITY, "%f", "Infinity"}, + {Double.POSITIVE_INFINITY, "%#.3f", "Infinity"}, + {Double.POSITIVE_INFINITY, "%,5f", "Infinity"}, + {Double.POSITIVE_INFINITY, "%- (12.0f", " Infinity "}, + {Double.POSITIVE_INFINITY, "%#+0(1.6f", "+Infinity"}, + {Double.POSITIVE_INFINITY, "%-+(8.4f", "+Infinity"}, + {Double.POSITIVE_INFINITY, "% 0#(9.8f", " Infinity"}, + + {Double.NEGATIVE_INFINITY, "%f", "-Infinity"}, + {Double.NEGATIVE_INFINITY, "%#.3f", "-Infinity"}, + {Double.NEGATIVE_INFINITY, "%,5f", "-Infinity"}, + {Double.NEGATIVE_INFINITY, "%- (12.0f", "(Infinity) "}, + {Double.NEGATIVE_INFINITY, "%#+0(1.6f", "(Infinity)"}, + {Double.NEGATIVE_INFINITY, "%-+(8.4f", "(Infinity)"}, + {Double.NEGATIVE_INFINITY, "% 0#(9.8f", "(Infinity)"}, + }; + final int input = 0; + final int pattern = 1; + final int output = 2; + for (int i = 0; i < tripleF.length; i++) { + f = new Formatter(Locale.GERMAN); + f.format((String)tripleF[i][pattern], tripleF[i][input]); + assertEquals("triple[" + i + "]:" + tripleF[i][input] + ",pattern[" + + i + "]:" + tripleF[i][pattern], + tripleF[i][output], f.toString()); + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for Float/Double + * conversion type 'a' and 'A' + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionA() { + Formatter f = null; + final Object[][] tripleA = { + {-0f, "%a", "-0x0.0p0"}, + {-0f, "%#.3a", "-0x0.000p0"}, + {-0f, "%5a", "-0x0.0p0"}, + {-0f, "%- 12.0a", "-0x0.0p0 "}, + {-0f, "%#+01.6a", "-0x0.000000p0"}, + {-0f, "%-+8.4a", "-0x0.0000p0"}, + + {0f, "%a", "0x0.0p0"}, + {0f, "%#.3a", "0x0.000p0"}, + {0f, "%5a", "0x0.0p0"}, + {0f, "%- 12.0a", " 0x0.0p0 "}, + {0f, "%#+01.6a", "+0x0.000000p0"}, + {0f, "%-+8.4a", "+0x0.0000p0"}, + + {1234f, "%a", "0x1.348p10"}, + {1234f, "%#.3a", "0x1.348p10"}, + {1234f, "%5a", "0x1.348p10"}, + {1234f, "%- 12.0a", " 0x1.3p10 "}, + {1234f, "%#+01.6a", "+0x1.348000p10"}, + {1234f, "%-+8.4a", "+0x1.3480p10"}, + + {1.f, "%a", "0x1.0p0"}, + {1.f, "%#.3a", "0x1.000p0"}, + {1.f, "%5a", "0x1.0p0"}, + {1.f, "%- 12.0a", " 0x1.0p0 "}, + {1.f, "%#+01.6a", "+0x1.000000p0"}, + {1.f, "%-+8.4a", "+0x1.0000p0"}, + + {-98f, "%a", "-0x1.88p6"}, + {-98f, "%#.3a", "-0x1.880p6"}, + {-98f, "%5a", "-0x1.88p6"}, + {-98f, "%- 12.0a", "-0x1.8p6 "}, + {-98f, "%#+01.6a", "-0x1.880000p6"}, + {-98f, "%-+8.4a", "-0x1.8800p6"}, + + {345.1234567f, "%a", "0x1.591f9ap8"}, + {345.1234567f, "%5a", "0x1.591f9ap8"}, + {345.1234567f, "%#+01.6a", "+0x1.591f9ap8"}, + + {-987654321.1234567f, "%a", "-0x1.d6f346p29"}, + {-987654321.1234567f, "%#.3a", "-0x1.d6fp29"}, + {-987654321.1234567f, "%5a", "-0x1.d6f346p29"}, + {-987654321.1234567f, "%- 12.0a", "-0x1.dp29 "}, + {-987654321.1234567f, "%#+01.6a", "-0x1.d6f346p29"}, + {-987654321.1234567f, "%-+8.4a", "-0x1.d6f3p29"}, + + {Float.MAX_VALUE, "%a", "0x1.fffffep127"}, + {Float.MAX_VALUE, "%5a", "0x1.fffffep127"}, + {Float.MAX_VALUE, "%#+01.6a", "+0x1.fffffep127"}, + + {Float.NaN, "%a", "NaN"}, + {Float.NaN, "%#.3a", "NaN"}, + {Float.NaN, "%5a", " NaN"}, + {Float.NaN, "%- 12.0a", "NaN "}, + {Float.NaN, "%#+01.6a", "NaN"}, + {Float.NaN, "%-+8.4a", "NaN "}, + + {Float.NEGATIVE_INFINITY, "%a", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%#.3a", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%5a", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%- 12.0a", "-Infinity "}, + {Float.NEGATIVE_INFINITY, "%#+01.6a", "-Infinity"}, + {Float.NEGATIVE_INFINITY, "%-+8.4a", "-Infinity"}, + + {Float.POSITIVE_INFINITY, "%a", "Infinity"}, + {Float.POSITIVE_INFINITY, "%#.3a", "Infinity"}, + {Float.POSITIVE_INFINITY, "%5a", "Infinity"}, + {Float.POSITIVE_INFINITY, "%- 12.0a", " Infinity "}, + {Float.POSITIVE_INFINITY, "%#+01.6a", "+Infinity"}, + {Float.POSITIVE_INFINITY, "%-+8.4a", "+Infinity"}, + + {-0d, "%a", "-0x0.0p0"}, + {-0d, "%#.3a", "-0x0.000p0"}, + {-0d, "%5a", "-0x0.0p0"}, + {-0d, "%- 12.0a", "-0x0.0p0 "}, + {-0d, "%#+01.6a", "-0x0.000000p0"}, + {-0d, "%-+8.4a", "-0x0.0000p0"}, + + {0d, "%a", "0x0.0p0"}, + {0d, "%#.3a", "0x0.000p0"}, + {0d, "%5a", "0x0.0p0"}, + {0d, "%- 12.0a", " 0x0.0p0 "}, + {0d, "%#+01.6a", "+0x0.000000p0"}, + {0d, "%-+8.4a", "+0x0.0000p0"}, + + {1d, "%a", "0x1.0p0"}, + {1d, "%#.3a", "0x1.000p0"}, + {1d, "%5a", "0x1.0p0"}, + {1d, "%- 12.0a", " 0x1.0p0 "}, + {1d, "%#+01.6a", "+0x1.000000p0"}, + {1d, "%-+8.4a", "+0x1.0000p0"}, + + {-1d, "%a", "-0x1.0p0"}, + {-1d, "%#.3a", "-0x1.000p0"}, + {-1d, "%5a", "-0x1.0p0"}, + {-1d, "%- 12.0a", "-0x1.0p0 "}, + {-1d, "%#+01.6a", "-0x1.000000p0"}, + {-1d, "%-+8.4a", "-0x1.0000p0"}, + + {.00000001d, "%a", "0x1.5798ee2308c3ap-27"}, + {.00000001d, "%5a", "0x1.5798ee2308c3ap-27"}, + {.00000001d, "%- 12.0a", " 0x1.5p-27 "}, + {.00000001d, "%#+01.6a", "+0x1.5798eep-27"}, + + {1000.10d, "%a", "0x1.f40cccccccccdp9"}, + {1000.10d, "%5a", "0x1.f40cccccccccdp9"}, + {1000.10d, "%- 12.0a", " 0x1.fp9 "}, + + {0.1d, "%a", "0x1.999999999999ap-4"}, + {0.1d, "%5a", "0x1.999999999999ap-4"}, + + {-2.d, "%a", "-0x1.0p1"}, + {-2.d, "%#.3a", "-0x1.000p1"}, + {-2.d, "%5a", "-0x1.0p1"}, + {-2.d, "%- 12.0a", "-0x1.0p1 "}, + {-2.d, "%#+01.6a", "-0x1.000000p1"}, + {-2.d, "%-+8.4a", "-0x1.0000p1"}, + + {-.00009d, "%a", "-0x1.797cc39ffd60fp-14"}, + {-.00009d, "%5a", "-0x1.797cc39ffd60fp-14"}, + + {-1234567890.012345678d, "%a", "-0x1.26580b480ca46p30"}, + {-1234567890.012345678d, "%5a", "-0x1.26580b480ca46p30"}, + {-1234567890.012345678d, "%- 12.0a", "-0x1.2p30 "}, + {-1234567890.012345678d, "%#+01.6a", "-0x1.26580bp30"}, + {-1234567890.012345678d, "%-+8.4a", "-0x1.2658p30"}, + + {Double.MAX_VALUE, "%a", "0x1.fffffffffffffp1023"}, + {Double.MAX_VALUE, "%5a", "0x1.fffffffffffffp1023"}, + + {Double.MIN_VALUE, "%a", "0x0.0000000000001p-1022"}, + {Double.MIN_VALUE, "%5a", "0x0.0000000000001p-1022"}, + + {Double.NaN, "%a", "NaN"}, + {Double.NaN, "%#.3a", "NaN"}, + {Double.NaN, "%5a", " NaN"}, + {Double.NaN, "%- 12.0a", "NaN "}, + {Double.NaN, "%#+01.6a", "NaN"}, + {Double.NaN, "%-+8.4a", "NaN "}, + + {Double.NEGATIVE_INFINITY, "%a", "-Infinity"}, + {Double.NEGATIVE_INFINITY, "%#.3a", "-Infinity"}, + {Double.NEGATIVE_INFINITY, "%5a", "-Infinity"}, + {Double.NEGATIVE_INFINITY, "%- 12.0a", "-Infinity "}, + {Double.NEGATIVE_INFINITY, "%#+01.6a", "-Infinity"}, + {Double.NEGATIVE_INFINITY, "%-+8.4a", "-Infinity"}, + + {Double.POSITIVE_INFINITY, "%a", "Infinity"}, + {Double.POSITIVE_INFINITY, "%#.3a", "Infinity"}, + {Double.POSITIVE_INFINITY, "%5a", "Infinity"}, + {Double.POSITIVE_INFINITY, "%- 12.0a", " Infinity "}, + {Double.POSITIVE_INFINITY, "%#+01.6a", "+Infinity"}, + {Double.POSITIVE_INFINITY, "%-+8.4a", "+Infinity"}, + + }; + final int input = 0; + final int pattern = 1; + final int output = 2; + for (int i = 0; i < tripleA.length; i++) { + f = new Formatter(Locale.UK); + f.format((String)tripleA[i][pattern], tripleA[i][input]); + assertEquals("triple[" + i + "]:" + tripleA[i][input] + ",pattern[" + + i + "]:" + tripleA[i][pattern], + tripleA[i][output], f.toString()); + + // test for conversion type 'A' + f = new Formatter(Locale.UK); + f.format(((String)tripleA[i][pattern]).toUpperCase(), tripleA[i][input]); + assertEquals("triple[" + i + "]:" + tripleA[i][input] + ",pattern[" + + i + "]:" + tripleA[i][pattern], ((String)tripleA[i][output]) + .toUpperCase(Locale.UK), f.toString()); + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for BigDecimal + * conversion type 'e' and 'E' + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalConversionE() { + Formatter f = null; + final Object[][] tripleE = { + {BigDecimal.ZERO, "%e", "0.000000e+00"}, + {BigDecimal.ZERO, "%#.0e", "0.e+00"}, + {BigDecimal.ZERO, "%# 9.8e", " 0.00000000e+00"}, + {BigDecimal.ZERO, "%#+0(8.4e", "+0.0000e+00"}, + {BigDecimal.ZERO, "%-+17.6e", "+0.000000e+00 "}, + {BigDecimal.ZERO, "% 0(20e", " 00000000.000000e+00"}, + + {BigDecimal.ONE, "%e", "1.000000e+00"}, + {BigDecimal.ONE, "%#.0e", "1.e+00"}, + {BigDecimal.ONE, "%# 9.8e", " 1.00000000e+00"}, + {BigDecimal.ONE, "%#+0(8.4e", "+1.0000e+00"}, + {BigDecimal.ONE, "%-+17.6e", "+1.000000e+00 "}, + {BigDecimal.ONE, "% 0(20e", " 00000001.000000e+00"}, + + {BigDecimal.TEN, "%e", "1.000000e+01"}, + {BigDecimal.TEN, "%#.0e", "1.e+01"}, + {BigDecimal.TEN, "%# 9.8e", " 1.00000000e+01"}, + {BigDecimal.TEN, "%#+0(8.4e", "+1.0000e+01"}, + {BigDecimal.TEN, "%-+17.6e", "+1.000000e+01 "}, + {BigDecimal.TEN, "% 0(20e", " 00000001.000000e+01"}, + + {new BigDecimal(-1), "%e", "-1.000000e+00"}, + {new BigDecimal(-1), "%#.0e", "-1.e+00"}, + {new BigDecimal(-1), "%# 9.8e", "-1.00000000e+00"}, + {new BigDecimal(-1), "%#+0(8.4e", "(1.0000e+00)"}, + {new BigDecimal(-1), "%-+17.6e", "-1.000000e+00 "}, + {new BigDecimal(-1), "% 0(20e", "(0000001.000000e+00)"}, + + {new BigDecimal("5.000E999"), "%e", "5.000000e+999"}, + {new BigDecimal("5.000E999"), "%#.0e", "5.e+999"}, + {new BigDecimal("5.000E999"), "%# 9.8e", " 5.00000000e+999"}, + {new BigDecimal("5.000E999"), "%#+0(8.4e", "+5.0000e+999"}, + {new BigDecimal("5.000E999"), "%-+17.6e", "+5.000000e+999 "}, + {new BigDecimal("5.000E999"), "% 0(20e", " 0000005.000000e+999"}, + + {new BigDecimal("-5.000E999"), "%e", "-5.000000e+999"}, + {new BigDecimal("-5.000E999"), "%#.0e", "-5.e+999"}, + {new BigDecimal("-5.000E999"), "%# 9.8e", "-5.00000000e+999"}, + {new BigDecimal("-5.000E999"), "%#+0(8.4e", "(5.0000e+999)"}, + {new BigDecimal("-5.000E999"), "%-+17.6e", "-5.000000e+999 "}, + {new BigDecimal("-5.000E999"), "% 0(20e", "(000005.000000e+999)"}, + }; + final int input = 0; + final int pattern = 1; + final int output = 2; + for (int i = 0; i < tripleE.length; i++) { + f = new Formatter(Locale.US); + f.format((String)tripleE[i][pattern], tripleE[i][input]); + assertEquals("triple[" + i + "]:" + tripleE[i][input] + ",pattern[" + + i + "]:" + tripleE[i][pattern], + tripleE[i][output], f.toString()); + + // test for conversion type 'E' + f = new Formatter(Locale.US); + f.format(((String)tripleE[i][pattern]).toUpperCase(), tripleE[i][input]); + assertEquals("triple[" + i + "]:" + tripleE[i][input] + ",pattern[" + + i + "]:" + tripleE[i][pattern], ((String)tripleE[i][output]) + .toUpperCase(Locale.US), f.toString()); + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for BigDecimal + * conversion type 'g' and 'G' + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalConversionG() { + Formatter f = null; + final Object[][] tripleG = { + {BigDecimal.ZERO, "%g", "0.00000"}, + {BigDecimal.ZERO, "%.5g", "0.0000"}, + {BigDecimal.ZERO, "%- (,9.8g", " 0.0000000"}, + {BigDecimal.ZERO, "%+0(,8.4g", "+000.000"}, + {BigDecimal.ZERO, "%-+10.6g", "+0.00000 "}, + {BigDecimal.ZERO, "% 0(,12.0g", " 00000000000"}, + {BigDecimal.ONE, "%g", "1.00000"}, + {BigDecimal.ONE, "%.5g", "1.0000"}, + {BigDecimal.ONE, "%- (,9.8g", " 1.0000000"}, + {BigDecimal.ONE, "%+0(,8.4g", "+001.000"}, + {BigDecimal.ONE, "%-+10.6g", "+1.00000 "}, + {BigDecimal.ONE, "% 0(,12.0g", " 00000000001"}, + + {new BigDecimal(-1), "%g", "-1.00000"}, + {new BigDecimal(-1), "%.5g", "-1.0000"}, + {new BigDecimal(-1), "%- (,9.8g", "(1.0000000)"}, + {new BigDecimal(-1), "%+0(,8.4g", "(01.000)"}, + {new BigDecimal(-1), "%-+10.6g", "-1.00000 "}, + {new BigDecimal(-1), "% 0(,12.0g", "(0000000001)"}, + + {new BigDecimal(-0.000001), "%g", "-1.00000e-06"}, + {new BigDecimal(-0.000001), "%.5g", "-1.0000e-06"}, + {new BigDecimal(-0.000001), "%- (,9.8g", "(1.0000000e-06)"}, + {new BigDecimal(-0.000001), "%+0(,8.4g", "(1.000e-06)"}, + {new BigDecimal(-0.000001), "%-+10.6g", "-1.00000e-06"}, + {new BigDecimal(-0.000001), "% 0(,12.0g", "(000001e-06)"}, + + {new BigDecimal(0.0002), "%g", "0.000200000"}, + {new BigDecimal(0.0002), "%.5g", "0.00020000"}, + {new BigDecimal(0.0002), "%- (,9.8g", " 0.00020000000"}, + {new BigDecimal(0.0002), "%+0(,8.4g", "+0.0002000"}, + {new BigDecimal(0.0002), "%-+10.6g", "+0.000200000"}, + {new BigDecimal(0.0002), "% 0(,12.0g", " 000000.0002"}, + + {new BigDecimal(-0.003), "%g", "-0.00300000"}, + {new BigDecimal(-0.003), "%.5g", "-0.0030000"}, + {new BigDecimal(-0.003), "%- (,9.8g", "(0.0030000000)"}, + {new BigDecimal(-0.003), "%+0(,8.4g", "(0.003000)"}, + {new BigDecimal(-0.003), "%-+10.6g", "-0.00300000"}, + {new BigDecimal(-0.003), "% 0(,12.0g", "(000000.003)"}, + + {new BigDecimal("5.000E999"), "%g", "5.00000e+999"}, + {new BigDecimal("5.000E999"), "%.5g", "5.0000e+999"}, + {new BigDecimal("5.000E999"), "%- (,9.8g", " 5.0000000e+999"}, + {new BigDecimal("5.000E999"), "%+0(,8.4g", "+5.000e+999"}, + {new BigDecimal("5.000E999"), "%-+10.6g", "+5.00000e+999"}, + {new BigDecimal("5.000E999"), "% 0(,12.0g", " 000005e+999"}, + + {new BigDecimal("-5.000E999"), "%g", "-5.00000e+999"}, + {new BigDecimal("-5.000E999"), "%.5g", "-5.0000e+999"}, + {new BigDecimal("-5.000E999"), "%- (,9.8g", "(5.0000000e+999)"}, + {new BigDecimal("-5.000E999"), "%+0(,8.4g", "(5.000e+999)"}, + {new BigDecimal("-5.000E999"), "%-+10.6g", "-5.00000e+999"}, + {new BigDecimal("-5.000E999"), "% 0(,12.0g", "(00005e+999)"}, + }; + final int input = 0; + final int pattern = 1; + final int output = 2; + for (int i = 0; i < tripleG.length; i++) { + f = new Formatter(Locale.US); + f.format((String)tripleG[i][pattern], tripleG[i][input]); + assertEquals("triple[" + i + "]:" + tripleG[i][input] + ",pattern[" + + i + "]:" + tripleG[i][pattern], + tripleG[i][output], f.toString()); + + // test for conversion type 'G' + f = new Formatter(Locale.US); + f.format(((String)tripleG[i][pattern]).toUpperCase(), tripleG[i][input]); + assertEquals("triple[" + i + "]:" + tripleG[i][input] + ",pattern[" + + i + "]:" + tripleG[i][pattern], ((String)tripleG[i][output]) + .toUpperCase(Locale.US), f.toString()); + } + + f = new Formatter(Locale.GERMAN); + f.format("%- (,9.6g", new BigDecimal("4E6")); + /* + * fail on RI, spec says 'g' requires the output to be formatted in + * general scientific notation and the localization algorithm is + * applied. But RI format this case to 4.00000e+06, which does not + * conform to the German Locale + */ + assertEquals(" 4,00000e+06", f.toString()); + } + + /** + * @tests java.util.Formatter#format(String, Object...) for BigDecimal + * conversion type 'f' + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalConversionF() { + + Formatter f = null; + final int input = 0; + final int pattern = 1; + final int output = 2; + final Object[][] tripleF = { + {BigDecimal.ZERO, "%f", "0.000000"}, + {BigDecimal.ZERO, "%#.3f", "0.000"}, + {BigDecimal.ZERO, "%#,5f", "0.000000"}, + {BigDecimal.ZERO, "%- #(12.0f", " 0. "}, + {BigDecimal.ZERO, "%#+0(1.6f", "+0.000000"}, + {BigDecimal.ZERO, "%-+(8.4f", "+0.0000 "}, + {BigDecimal.ZERO, "% 0#(9.8f", " 0.00000000"}, + {BigDecimal.ONE, "%f", "1.000000"}, + {BigDecimal.ONE, "%#.3f", "1.000"}, + {BigDecimal.ONE, "%#,5f", "1.000000"}, + {BigDecimal.ONE, "%- #(12.0f", " 1. "}, + {BigDecimal.ONE, "%#+0(1.6f", "+1.000000"}, + {BigDecimal.ONE, "%-+(8.4f", "+1.0000 "}, + {BigDecimal.ONE, "% 0#(9.8f", " 1.00000000"}, + {BigDecimal.TEN, "%f", "10.000000"}, + {BigDecimal.TEN, "%#.3f", "10.000"}, + {BigDecimal.TEN, "%#,5f", "10.000000"}, + {BigDecimal.TEN, "%- #(12.0f", " 10. "}, + {BigDecimal.TEN, "%#+0(1.6f", "+10.000000"}, + {BigDecimal.TEN, "%-+(8.4f", "+10.0000"}, + {BigDecimal.TEN, "% 0#(9.8f", " 10.00000000"}, + {new BigDecimal(-1), "%f", "-1.000000"}, + {new BigDecimal(-1), "%#.3f", "-1.000"}, + {new BigDecimal(-1), "%#,5f", "-1.000000"}, + {new BigDecimal(-1), "%- #(12.0f", "(1.) "}, + {new BigDecimal(-1), "%#+0(1.6f", "(1.000000)"}, + {new BigDecimal(-1), "%-+(8.4f", "(1.0000)"}, + {new BigDecimal(-1), "% 0#(9.8f", "(1.00000000)"}, + {new BigDecimal("9999999999999999999999999999999999999999999"), "%f", "9999999999999999999999999999999999999999999.000000"}, + {new BigDecimal("9999999999999999999999999999999999999999999"), "%#.3f", "9999999999999999999999999999999999999999999.000"}, + {new BigDecimal("9999999999999999999999999999999999999999999"), "%#,5f", "9,999,999,999,999,999,999,999,999,999,999,999,999,999,999.000000"}, + {new BigDecimal("9999999999999999999999999999999999999999999"), "%- #(12.0f", " 9999999999999999999999999999999999999999999."}, + {new BigDecimal("9999999999999999999999999999999999999999999"), "%#+0(1.6f", "+9999999999999999999999999999999999999999999.000000"}, + {new BigDecimal("9999999999999999999999999999999999999999999"), "%-+(8.4f", "+9999999999999999999999999999999999999999999.0000"}, + {new BigDecimal("9999999999999999999999999999999999999999999"), "% 0#(9.8f", " 9999999999999999999999999999999999999999999.00000000"}, + {new BigDecimal("-9999999999999999999999999999999999999999999"), "%f", "-9999999999999999999999999999999999999999999.000000"}, + {new BigDecimal("-9999999999999999999999999999999999999999999"), "%#.3f", "-9999999999999999999999999999999999999999999.000"}, + {new BigDecimal("-9999999999999999999999999999999999999999999"), "%#,5f", "-9,999,999,999,999,999,999,999,999,999,999,999,999,999,999.000000"}, + {new BigDecimal("-9999999999999999999999999999999999999999999"), "%- #(12.0f", "(9999999999999999999999999999999999999999999.)"}, + {new BigDecimal("-9999999999999999999999999999999999999999999"), "%#+0(1.6f", "(9999999999999999999999999999999999999999999.000000)"}, + {new BigDecimal("-9999999999999999999999999999999999999999999"), "%-+(8.4f", "(9999999999999999999999999999999999999999999.0000)"}, + {new BigDecimal("-9999999999999999999999999999999999999999999"), "% 0#(9.8f", "(9999999999999999999999999999999999999999999.00000000)"}, + }; + for (int i = 0; i < tripleF.length; i++) { + f = new Formatter(Locale.US); + f.format((String)tripleF[i][pattern], tripleF[i][input]); + assertEquals("triple[" + i + "]:" + tripleF[i][input] + ",pattern[" + + i + "]:" + tripleF[i][pattern], tripleF[i][output], f.toString()); + } + + f = new Formatter(Locale.US); + f.format("%f", new BigDecimal("5.0E9")); + // error on RI + // RI throw ArrayIndexOutOfBoundsException + assertEquals("5000000000.000000", f.toString()); + } + + /** + * @tests java.util.Formatter#format(String, Object...) for exceptions in + * Float/Double/BigDecimal conversion type 'e', 'E', 'g', 'G', 'f', 'a', 'A' + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_FloatDoubleBigDecimalConversionException() { + Formatter f = null; + + final char[] conversions = { 'e', 'E', 'g', 'G', 'f', 'a', 'A' }; + final Object[] illArgs = { false, (byte) 1, (short) 2, 3, (long) 4, + new BigInteger("5"), new Character('c'), new Object(), + new Date() }; + for (int i = 0; i < illArgs.length; i++) { + for (int j = 0; j < conversions.length; j++) { + try { + f = new Formatter(Locale.UK); + f.format("%" + conversions[j], illArgs[i]); + fail("should throw IllegalFormatConversionException"); + } catch (IllegalFormatConversionException e) { + // expected + } + } + } + + try { + f = new Formatter(Locale.UK); + f.format("%a", new BigDecimal(1)); + fail("should throw IllegalFormatConversionException"); + } catch (IllegalFormatConversionException e) { + // expected + } + + try { + f = new Formatter(Locale.UK); + f.format("%A", new BigDecimal(1)); + fail("should throw IllegalFormatConversionException"); + } catch (IllegalFormatConversionException e) { + // expected + } + + final String[] flagsConversionMismatches = { "%,e", "%,E", "%#g", + "%#G", "%,a", "%,A", "%(a", "%(A" }; + for (int i = 0; i < flagsConversionMismatches.length; i++) { + try { + f = new Formatter(Locale.CHINA); + f.format(flagsConversionMismatches[i], new BigDecimal(1)); + fail("should throw FormatFlagsConversionMismatchException"); + } catch (FormatFlagsConversionMismatchException e) { + // expected + } + try { + f = new Formatter(Locale.JAPAN); + f.format(flagsConversionMismatches[i], (BigDecimal) null); + fail("should throw FormatFlagsConversionMismatchException"); + } catch (FormatFlagsConversionMismatchException e) { + // expected + } + } + + final String[] missingFormatWidths = { "%-0e", "%0e", "%-e", "%-0E", + "%0E", "%-E", "%-0g", "%0g", "%-g", "%-0G", "%0G", "%-G", + "%-0f", "%0f", "%-f", "%-0a", "%0a", "%-a", "%-0A", "%0A", + "%-A" }; + for (int i = 0; i < missingFormatWidths.length; i++) { + try { + f = new Formatter(Locale.KOREA); + f.format(missingFormatWidths[i], 1f); + fail("should throw MissingFormatWidthException"); + } catch (MissingFormatWidthException e) { + // expected + } + + try { + f = new Formatter(Locale.KOREA); + f.format(missingFormatWidths[i], (Float) null); + fail("should throw MissingFormatWidthException"); + } catch (MissingFormatWidthException e) { + // expected + } + } + + final String[] illFlags = { "%+ e", "%+ E", "%+ g", "%+ G", "%+ f", + "%+ a", "%+ A", "%-03e", "%-03E", "%-03g", "%-03G", "%-03f", + "%-03a", "%-03A" }; + for (int i = 0; i < illFlags.length; i++) { + try { + f = new Formatter(Locale.CANADA); + f.format(illFlags[i], 1.23d); + fail("should throw IllegalFormatFlagsException"); + } catch (IllegalFormatFlagsException e) { + // expected + } + + try { + f = new Formatter(Locale.CANADA); + f.format(illFlags[i], (Double) null); + fail("should throw IllegalFormatFlagsException"); + } catch (IllegalFormatFlagsException e) { + // expected + } + } + + f = new Formatter(Locale.US); + try { + f.format("%F", 1); + fail("should throw UnknownFormatConversionException"); + } catch (UnknownFormatConversionException e) { + // expected + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for + * Float/Double/BigDecimal exception throwing order + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_FloatDoubleBigDecimalExceptionOrder() { + Formatter f = null; + + /* + * Summary: UnknownFormatConversionException > + * MissingFormatWidthException > IllegalFormatFlagsException > + * FormatFlagsConversionMismatchException > + * IllegalFormatConversionException + * + */ + try { + // compare FormatFlagsConversionMismatchException and + // IllegalFormatConversionException + f = new Formatter(Locale.US); + f.format("%,e", (byte) 1); + fail("should throw FormatFlagsConversionMismatchException"); + } catch (FormatFlagsConversionMismatchException e) { + // expected + } + + try { + // compare IllegalFormatFlagsException and + // FormatFlagsConversionMismatchException + f = new Formatter(Locale.US); + f.format("%+ ,e", 1f); + fail("should throw IllegalFormatFlagsException"); + } catch (IllegalFormatFlagsException e) { + // expected + } + + try { + // compare MissingFormatWidthException and + // IllegalFormatFlagsException + f = new Formatter(Locale.US); + f.format("%+ -e", 1f); + fail("should throw MissingFormatWidthException"); + } catch (MissingFormatWidthException e) { + // expected + } + + try { + // compare UnknownFormatConversionException and + // MissingFormatWidthException + f = new Formatter(Locale.US); + f.format("%-F", 1f); + fail("should throw UnknownFormatConversionException"); + } catch (UnknownFormatConversionException e) { + // expected + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for BigDecimal + * exception throwing order + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalExceptionOrder() { + Formatter f = null; + BigDecimal bd = new BigDecimal("1.0"); + + /* + * Summary: UnknownFormatConversionException > + * MissingFormatWidthException > IllegalFormatFlagsException > + * FormatFlagsConversionMismatchException > + * IllegalFormatConversionException + * + */ + try { + // compare FormatFlagsConversionMismatchException and + // IllegalFormatConversionException + f = new Formatter(Locale.US); + f.format("%,e", (byte) 1); + fail("should throw FormatFlagsConversionMismatchException"); + } catch (FormatFlagsConversionMismatchException e) { + // expected + } + + try { + // compare IllegalFormatFlagsException and + // FormatFlagsConversionMismatchException + f = new Formatter(Locale.US); + f.format("%+ ,e", bd); + fail("should throw IllegalFormatFlagsException"); + } catch (IllegalFormatFlagsException e) { + // expected + } + + try { + // compare MissingFormatWidthException and + // IllegalFormatFlagsException + f = new Formatter(Locale.US); + f.format("%+ -e", bd); + fail("should throw MissingFormatWidthException"); + } catch (MissingFormatWidthException e) { + // expected + } + + // compare UnknownFormatConversionException and + // MissingFormatWidthException + try { + f = new Formatter(Locale.US); + f.format("%-F", bd); + fail("should throw UnknownFormatConversionException"); + } catch (UnknownFormatConversionException e) { + // expected + } + } + + /** + * @tests java.util.Formatter#format(String, Object...) for null argment for + * Float/Double/BigDecimal conversion + */ + public void test_formatLjava_lang_String$Ljava_lang_Object_FloatDoubleBigDecimalNullConversion() { + Formatter f = null; + + // test (Float)null + f = new Formatter(Locale.FRANCE); + f.format("%#- (9.0e", (Float) null); + assertEquals(" ", f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format("%-+(1.6E", (Float) null); + assertEquals("NULL", f.toString()); + + f = new Formatter(Locale.UK); + f.format("%+0(,8.4g", (Float) null); + assertEquals(" null", f.toString()); + + f = new Formatter(Locale.FRANCE); + f.format("%- (9.8G", (Float) null); + assertEquals("NULL ", f.toString()); + + f = new Formatter(Locale.FRANCE); + f.format("%- (12.1f", (Float) null); + assertEquals("n ", f.toString()); + + f = new Formatter(Locale.FRANCE); + f.format("% .4a", (Float) null); + assertEquals("null", f.toString()); + + f = new Formatter(Locale.FRANCE); + f.format("%06A", (Float) null); + assertEquals(" NULL", f.toString()); + + // test (Double)null + f = new Formatter(Locale.GERMAN); + f.format("%- (9e", (Double) null); + assertEquals("null ", f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format("%#-+(1.6E", (Double) null); + assertEquals("NULL", f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format("%+0(6.4g", (Double) null); + assertEquals(" null", f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format("%- (,5.8G", (Double) null); + assertEquals("NULL ", f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format("% (.4f", (Double) null); + assertEquals("null", f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format("%#.6a", (Double) null); + assertEquals("null", f.toString()); + + f = new Formatter(Locale.GERMAN); + f.format("% 2.5A", (Double) null); + assertEquals("NULL", f.toString()); + + // test (BigDecimal)null + f = new Formatter(Locale.UK); + f.format("%#- (6.2e", (BigDecimal) null); + assertEquals("nu ", f.toString()); + + f = new Formatter(Locale.UK); + f.format("%-+(1.6E", (BigDecimal) null); + assertEquals("NULL", f.toString()); + + f = new Formatter(Locale.UK); + f.format("%+-(,5.3g", (BigDecimal) null); + assertEquals("nul ", f.toString()); + + f = new Formatter(Locale.UK); + f.format("%0 3G", (BigDecimal) null); + assertEquals("NULL", f.toString()); + + f = new Formatter(Locale.UK); + f.format("%0 (9.0G", (BigDecimal) null); + assertEquals(" ", f.toString()); + + f = new Formatter(Locale.UK); + f.format("% (.5f", (BigDecimal) null); + assertEquals("null", f.toString()); + + f = new Formatter(Locale.UK); + f.format("%06a", (BigDecimal) null); + assertEquals(" null", f.toString()); + + f = new Formatter(Locale.UK); + f.format("% .5A", (BigDecimal) null); + assertEquals("NULL", f.toString()); + } + + /** + * Setup resource files for testing + */ + protected void setUp() throws IOException { + notExist = File.createTempFile("notexist", null); + notExist.delete(); + + fileWithContent = File.createTempFile("filewithcontent", null); + BufferedOutputStream bw = new BufferedOutputStream( + new FileOutputStream(fileWithContent)); + bw.write(1);// write something into the file + bw.close(); + + readOnly = File.createTempFile("readonly", null); + readOnly.setReadOnly(); + + secret = File.createTempFile("secret", null); + + defaultTimeZone = TimeZone.getDefault(); + TimeZone cst = TimeZone.getTimeZone("Asia/Shanghai"); + TimeZone.setDefault(cst); + } + + /** + * Delete the resource files if they exist + */ + protected void tearDown() { + if (notExist.exists()) { + notExist.delete(); + } + + if (fileWithContent.exists()) { + fileWithContent.delete(); + } + if (readOnly.exists()) { + readOnly.delete(); + } + if (secret.exists()) { + secret.delete(); + } + + TimeZone.setDefault(defaultTimeZone); + } +} diff --git a/Tests.Runtime.Standard/Java9/Java9Lexer.cs b/Tests.Runtime.Standard/Java9/Java9Lexer.cs new file mode 100644 index 0000000..38c279e --- /dev/null +++ b/Tests.Runtime.Standard/Java9/Java9Lexer.cs @@ -0,0 +1,1244 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// ANTLR Version: 4.7.2 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +// Generated from C:\Users\Spitz\source\repos\AntlrBug_40\AntlrConsole3\Java9Lexer.g4 by ANTLR 4.7.2 + +// Unreachable code detected +#pragma warning disable 0162 +// The variable '...' is assigned but its value is never used +#pragma warning disable 0219 +// Missing XML comment for publicly visible type or member '...' +#pragma warning disable 1591 +// Ambiguous reference in cref attribute +#pragma warning disable 419 + + +using System.Linq; +using System.Text.RegularExpressions; + +using System; +using System.IO; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Atn; +using Antlr4.Runtime.Misc; +using DFA = Antlr4.Runtime.Dfa.DFA; + +[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.7.2")] +[System.CLSCompliant(false)] +public partial class Java9Lexer : Lexer { + protected static DFA[] decisionToDFA; + protected static PredictionContextCache sharedContextCache = new PredictionContextCache(); + public const int + ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, + CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, + ENUM=16, EXPORTS=17, EXTENDS=18, FINAL=19, FINALLY=20, FLOAT=21, FOR=22, + IF=23, GOTO=24, IMPLEMENTS=25, IMPORT=26, INSTANCEOF=27, INT=28, INTERFACE=29, + LONG=30, MODULE=31, NATIVE=32, NEW=33, OPEN=34, OPENS=35, PACKAGE=36, + PRIVATE=37, PROTECTED=38, PROVIDES=39, PUBLIC=40, REQUIRES=41, RETURN=42, + SHORT=43, STATIC=44, STRICTFP=45, SUPER=46, SWITCH=47, SYNCHRONIZED=48, + THIS=49, THROW=50, THROWS=51, TO=52, TRANSIENT=53, TRANSITIVE=54, TRY=55, + USES=56, VOID=57, VOLATILE=58, WHILE=59, WITH=60, UNDER_SCORE=61, IntegerLiteral=62, + FloatingPointLiteral=63, BooleanLiteral=64, CharacterLiteral=65, StringLiteral=66, + NullLiteral=67, LPAREN=68, RPAREN=69, LBRACE=70, RBRACE=71, LBRACK=72, + RBRACK=73, SEMI=74, COMMA=75, DOT=76, ELLIPSIS=77, AT=78, COLONCOLON=79, + ASSIGN=80, GT=81, LT=82, BANG=83, TILDE=84, QUESTION=85, COLON=86, ARROW=87, + EQUAL=88, LE=89, GE=90, NOTEQUAL=91, AND=92, OR=93, INC=94, DEC=95, ADD=96, + SUB=97, MUL=98, DIV=99, BITAND=100, BITOR=101, CARET=102, MOD=103, ADD_ASSIGN=104, + SUB_ASSIGN=105, MUL_ASSIGN=106, DIV_ASSIGN=107, AND_ASSIGN=108, OR_ASSIGN=109, + XOR_ASSIGN=110, MOD_ASSIGN=111, LSHIFT_ASSIGN=112, RSHIFT_ASSIGN=113, + URSHIFT_ASSIGN=114, Identifier=115, WS=116, COMMENT=117, LINE_COMMENT=118; + public const int + COMMENTS_CHANNEL=2; + public static string[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", "COMMENTS_CHANNEL" + }; + + public static string[] modeNames = { + "DEFAULT_MODE" + }; + + public static readonly string[] ruleNames = { + "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", + "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", + "EXPORTS", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", + "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "MODULE", + "NATIVE", "NEW", "OPEN", "OPENS", "PACKAGE", "PRIVATE", "PROTECTED", "PROVIDES", + "PUBLIC", "REQUIRES", "RETURN", "SHORT", "STATIC", "STRICTFP", "SUPER", + "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TO", "TRANSIENT", + "TRANSITIVE", "TRY", "USES", "VOID", "VOLATILE", "WHILE", "WITH", "UNDER_SCORE", + "IntegerLiteral", "DecimalIntegerLiteral", "HexIntegerLiteral", "OctalIntegerLiteral", + "BinaryIntegerLiteral", "IntegerTypeSuffix", "DecimalNumeral", "Digits", + "Digit", "NonZeroDigit", "DigitsAndUnderscores", "DigitOrUnderscore", + "Underscores", "HexNumeral", "HexDigits", "HexDigit", "HexDigitsAndUnderscores", + "HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", "OctalDigit", "OctalDigitsAndUnderscores", + "OctalDigitOrUnderscore", "BinaryNumeral", "BinaryDigits", "BinaryDigit", + "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", "FloatingPointLiteral", + "DecimalFloatingPointLiteral", "ExponentPart", "ExponentIndicator", "SignedInteger", + "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", "HexSignificand", + "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", "CharacterLiteral", + "SingleCharacter", "StringLiteral", "StringCharacters", "StringCharacter", + "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", "NullLiteral", + "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", + "DOT", "ELLIPSIS", "AT", "COLONCOLON", "ASSIGN", "GT", "LT", "BANG", "TILDE", + "QUESTION", "COLON", "ARROW", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", + "OR", "INC", "DEC", "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", + "MOD", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", + "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", + "URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", "WS", + "COMMENT", "LINE_COMMENT" + }; + + + private class Character + { + public static bool isJavaIdentifierPart(int c) + { + if (Char.IsLetter((char)c)) + return true; + else if (c == (int)'$') + return true; + else if (c == (int)'_') + return true; + else if (Char.IsDigit((char)c)) + return true; + else if (Char.IsNumber((char)c)) + return true; + return false; + } + + public static bool isJavaIdentifierStart(int c) + { + if (Char.IsLetter((char)c)) + return true; + else if (c == (int)'$') + return true; + else if (c == (int)'_') + return true; + return false; + } + + public static int toCodePoint(int high, int low) + { + return Char.ConvertToUtf32((char)high, (char)low); + } + } + + + public Java9Lexer(ICharStream input) + : this(input, Console.Out, Console.Error) { } + + public Java9Lexer(ICharStream input, TextWriter output, TextWriter errorOutput) + : base(input, output, errorOutput) + { + Interpreter = new LexerATNSimulator(this, _ATN, decisionToDFA, sharedContextCache); + } + + private static readonly string[] _LiteralNames = { + null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", + "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", + "'do'", "'double'", "'else'", "'enum'", "'exports'", "'extends'", "'final'", + "'finally'", "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", + "'instanceof'", "'int'", "'interface'", "'long'", "'module'", "'native'", + "'new'", "'open'", "'opens'", "'package'", "'private'", "'protected'", + "'provides'", "'public'", "'requires'", "'return'", "'short'", "'static'", + "'strictfp'", "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", + "'throws'", "'to'", "'transient'", "'transitive'", "'try'", "'uses'", + "'void'", "'volatile'", "'while'", "'with'", "'_'", null, null, null, + null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", "';'", + "','", "'.'", "'...'", "'@'", "'::'", "'='", "'>'", "'<'", "'!'", "'~'", + "'?'", "':'", "'->'", "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", + "'++'", "'--'", "'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", + "'+='", "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", + "'>>='", "'>>>='" + }; + private static readonly string[] _SymbolicNames = { + null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", + "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", + "ENUM", "EXPORTS", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", + "GOTO", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", + "MODULE", "NATIVE", "NEW", "OPEN", "OPENS", "PACKAGE", "PRIVATE", "PROTECTED", + "PROVIDES", "PUBLIC", "REQUIRES", "RETURN", "SHORT", "STATIC", "STRICTFP", + "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TO", "TRANSIENT", + "TRANSITIVE", "TRY", "USES", "VOID", "VOLATILE", "WHILE", "WITH", "UNDER_SCORE", + "IntegerLiteral", "FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", + "StringLiteral", "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", + "LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", "ELLIPSIS", "AT", "COLONCOLON", + "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "ARROW", "EQUAL", + "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", + "DIV", "BITAND", "BITOR", "CARET", "MOD", "ADD_ASSIGN", "SUB_ASSIGN", + "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", + "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", "WS", + "COMMENT", "LINE_COMMENT" + }; + public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames); + + [NotNull] + public override IVocabulary Vocabulary + { + get + { + return DefaultVocabulary; + } + } + + public override string GrammarFileName { get { return "Java9Lexer.g4"; } } + + public override string[] RuleNames { get { return ruleNames; } } + + public override string[] ChannelNames { get { return channelNames; } } + + public override string[] ModeNames { get { return modeNames; } } + + public override string SerializedAtn { get { return new string(_serializedATN); } } + + static Java9Lexer() { + decisionToDFA = new DFA[_ATN.NumberOfDecisions]; + for (int i = 0; i < _ATN.NumberOfDecisions; i++) { + decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i); + } + } + public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 159 : return JavaLetter_sempred(_localctx, predIndex); + case 160 : return JavaLetterOrDigit_sempred(_localctx, predIndex); + } + return true; + } + private bool JavaLetter_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 0: return Character.isJavaIdentifierStart(this.InputStream.LA(-1)); + case 1: return Character.isJavaIdentifierStart(Character.toCodePoint((char)this.InputStream.LA(-2), (char)this.InputStream.LA(-1))); + } + return true; + } + private bool JavaLetterOrDigit_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 2: return Character.isJavaIdentifierPart(this.InputStream.LA(-1)); + case 3: return Character.isJavaIdentifierPart(Character.toCodePoint((char)this.InputStream.LA(-2), (char)this.InputStream.LA(-1))); + } + return true; + } + + private static char[] _serializedATN = { + '\x3', '\x608B', '\xA72A', '\x8133', '\xB9ED', '\x417C', '\x3BE7', '\x7786', + '\x5964', '\x2', 'x', '\x4A8', '\b', '\x1', '\x4', '\x2', '\t', '\x2', + '\x4', '\x3', '\t', '\x3', '\x4', '\x4', '\t', '\x4', '\x4', '\x5', '\t', + '\x5', '\x4', '\x6', '\t', '\x6', '\x4', '\a', '\t', '\a', '\x4', '\b', + '\t', '\b', '\x4', '\t', '\t', '\t', '\x4', '\n', '\t', '\n', '\x4', '\v', + '\t', '\v', '\x4', '\f', '\t', '\f', '\x4', '\r', '\t', '\r', '\x4', '\xE', + '\t', '\xE', '\x4', '\xF', '\t', '\xF', '\x4', '\x10', '\t', '\x10', '\x4', + '\x11', '\t', '\x11', '\x4', '\x12', '\t', '\x12', '\x4', '\x13', '\t', + '\x13', '\x4', '\x14', '\t', '\x14', '\x4', '\x15', '\t', '\x15', '\x4', + '\x16', '\t', '\x16', '\x4', '\x17', '\t', '\x17', '\x4', '\x18', '\t', + '\x18', '\x4', '\x19', '\t', '\x19', '\x4', '\x1A', '\t', '\x1A', '\x4', + '\x1B', '\t', '\x1B', '\x4', '\x1C', '\t', '\x1C', '\x4', '\x1D', '\t', + '\x1D', '\x4', '\x1E', '\t', '\x1E', '\x4', '\x1F', '\t', '\x1F', '\x4', + ' ', '\t', ' ', '\x4', '!', '\t', '!', '\x4', '\"', '\t', '\"', '\x4', + '#', '\t', '#', '\x4', '$', '\t', '$', '\x4', '%', '\t', '%', '\x4', '&', + '\t', '&', '\x4', '\'', '\t', '\'', '\x4', '(', '\t', '(', '\x4', ')', + '\t', ')', '\x4', '*', '\t', '*', '\x4', '+', '\t', '+', '\x4', ',', '\t', + ',', '\x4', '-', '\t', '-', '\x4', '.', '\t', '.', '\x4', '/', '\t', '/', + '\x4', '\x30', '\t', '\x30', '\x4', '\x31', '\t', '\x31', '\x4', '\x32', + '\t', '\x32', '\x4', '\x33', '\t', '\x33', '\x4', '\x34', '\t', '\x34', + '\x4', '\x35', '\t', '\x35', '\x4', '\x36', '\t', '\x36', '\x4', '\x37', + '\t', '\x37', '\x4', '\x38', '\t', '\x38', '\x4', '\x39', '\t', '\x39', + '\x4', ':', '\t', ':', '\x4', ';', '\t', ';', '\x4', '<', '\t', '<', '\x4', + '=', '\t', '=', '\x4', '>', '\t', '>', '\x4', '?', '\t', '?', '\x4', '@', + '\t', '@', '\x4', '\x41', '\t', '\x41', '\x4', '\x42', '\t', '\x42', '\x4', + '\x43', '\t', '\x43', '\x4', '\x44', '\t', '\x44', '\x4', '\x45', '\t', + '\x45', '\x4', '\x46', '\t', '\x46', '\x4', 'G', '\t', 'G', '\x4', 'H', + '\t', 'H', '\x4', 'I', '\t', 'I', '\x4', 'J', '\t', 'J', '\x4', 'K', '\t', + 'K', '\x4', 'L', '\t', 'L', '\x4', 'M', '\t', 'M', '\x4', 'N', '\t', 'N', + '\x4', 'O', '\t', 'O', '\x4', 'P', '\t', 'P', '\x4', 'Q', '\t', 'Q', '\x4', + 'R', '\t', 'R', '\x4', 'S', '\t', 'S', '\x4', 'T', '\t', 'T', '\x4', 'U', + '\t', 'U', '\x4', 'V', '\t', 'V', '\x4', 'W', '\t', 'W', '\x4', 'X', '\t', + 'X', '\x4', 'Y', '\t', 'Y', '\x4', 'Z', '\t', 'Z', '\x4', '[', '\t', '[', + '\x4', '\\', '\t', '\\', '\x4', ']', '\t', ']', '\x4', '^', '\t', '^', + '\x4', '_', '\t', '_', '\x4', '`', '\t', '`', '\x4', '\x61', '\t', '\x61', + '\x4', '\x62', '\t', '\x62', '\x4', '\x63', '\t', '\x63', '\x4', '\x64', + '\t', '\x64', '\x4', '\x65', '\t', '\x65', '\x4', '\x66', '\t', '\x66', + '\x4', 'g', '\t', 'g', '\x4', 'h', '\t', 'h', '\x4', 'i', '\t', 'i', '\x4', + 'j', '\t', 'j', '\x4', 'k', '\t', 'k', '\x4', 'l', '\t', 'l', '\x4', 'm', + '\t', 'm', '\x4', 'n', '\t', 'n', '\x4', 'o', '\t', 'o', '\x4', 'p', '\t', + 'p', '\x4', 'q', '\t', 'q', '\x4', 'r', '\t', 'r', '\x4', 's', '\t', 's', + '\x4', 't', '\t', 't', '\x4', 'u', '\t', 'u', '\x4', 'v', '\t', 'v', '\x4', + 'w', '\t', 'w', '\x4', 'x', '\t', 'x', '\x4', 'y', '\t', 'y', '\x4', 'z', + '\t', 'z', '\x4', '{', '\t', '{', '\x4', '|', '\t', '|', '\x4', '}', '\t', + '}', '\x4', '~', '\t', '~', '\x4', '\x7F', '\t', '\x7F', '\x4', '\x80', + '\t', '\x80', '\x4', '\x81', '\t', '\x81', '\x4', '\x82', '\t', '\x82', + '\x4', '\x83', '\t', '\x83', '\x4', '\x84', '\t', '\x84', '\x4', '\x85', + '\t', '\x85', '\x4', '\x86', '\t', '\x86', '\x4', '\x87', '\t', '\x87', + '\x4', '\x88', '\t', '\x88', '\x4', '\x89', '\t', '\x89', '\x4', '\x8A', + '\t', '\x8A', '\x4', '\x8B', '\t', '\x8B', '\x4', '\x8C', '\t', '\x8C', + '\x4', '\x8D', '\t', '\x8D', '\x4', '\x8E', '\t', '\x8E', '\x4', '\x8F', + '\t', '\x8F', '\x4', '\x90', '\t', '\x90', '\x4', '\x91', '\t', '\x91', + '\x4', '\x92', '\t', '\x92', '\x4', '\x93', '\t', '\x93', '\x4', '\x94', + '\t', '\x94', '\x4', '\x95', '\t', '\x95', '\x4', '\x96', '\t', '\x96', + '\x4', '\x97', '\t', '\x97', '\x4', '\x98', '\t', '\x98', '\x4', '\x99', + '\t', '\x99', '\x4', '\x9A', '\t', '\x9A', '\x4', '\x9B', '\t', '\x9B', + '\x4', '\x9C', '\t', '\x9C', '\x4', '\x9D', '\t', '\x9D', '\x4', '\x9E', + '\t', '\x9E', '\x4', '\x9F', '\t', '\x9F', '\x4', '\xA0', '\t', '\xA0', + '\x4', '\xA1', '\t', '\xA1', '\x4', '\xA2', '\t', '\xA2', '\x4', '\xA3', + '\t', '\xA3', '\x4', '\xA4', '\t', '\xA4', '\x4', '\xA5', '\t', '\xA5', + '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', + '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x3', + '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', + '\x3', '\x3', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', + '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x5', + '\x3', '\x5', '\x3', '\x5', '\x3', '\x5', '\x3', '\x5', '\x3', '\x5', + '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', + '\x3', '\a', '\x3', '\a', '\x3', '\a', '\x3', '\a', '\x3', '\a', '\x3', + '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', + '\x3', '\t', '\x3', '\t', '\x3', '\t', '\x3', '\t', '\x3', '\t', '\x3', + '\n', '\x3', '\n', '\x3', '\n', '\x3', '\n', '\x3', '\n', '\x3', '\n', + '\x3', '\v', '\x3', '\v', '\x3', '\v', '\x3', '\v', '\x3', '\v', '\x3', + '\v', '\x3', '\f', '\x3', '\f', '\x3', '\f', '\x3', '\f', '\x3', '\f', + '\x3', '\f', '\x3', '\f', '\x3', '\f', '\x3', '\f', '\x3', '\r', '\x3', + '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', + '\x3', '\r', '\x3', '\xE', '\x3', '\xE', '\x3', '\xE', '\x3', '\xF', '\x3', + '\xF', '\x3', '\xF', '\x3', '\xF', '\x3', '\xF', '\x3', '\xF', '\x3', + '\xF', '\x3', '\x10', '\x3', '\x10', '\x3', '\x10', '\x3', '\x10', '\x3', + '\x10', '\x3', '\x11', '\x3', '\x11', '\x3', '\x11', '\x3', '\x11', '\x3', + '\x11', '\x3', '\x12', '\x3', '\x12', '\x3', '\x12', '\x3', '\x12', '\x3', + '\x12', '\x3', '\x12', '\x3', '\x12', '\x3', '\x12', '\x3', '\x13', '\x3', + '\x13', '\x3', '\x13', '\x3', '\x13', '\x3', '\x13', '\x3', '\x13', '\x3', + '\x13', '\x3', '\x13', '\x3', '\x14', '\x3', '\x14', '\x3', '\x14', '\x3', + '\x14', '\x3', '\x14', '\x3', '\x14', '\x3', '\x15', '\x3', '\x15', '\x3', + '\x15', '\x3', '\x15', '\x3', '\x15', '\x3', '\x15', '\x3', '\x15', '\x3', + '\x15', '\x3', '\x16', '\x3', '\x16', '\x3', '\x16', '\x3', '\x16', '\x3', + '\x16', '\x3', '\x16', '\x3', '\x17', '\x3', '\x17', '\x3', '\x17', '\x3', + '\x17', '\x3', '\x18', '\x3', '\x18', '\x3', '\x18', '\x3', '\x19', '\x3', + '\x19', '\x3', '\x19', '\x3', '\x19', '\x3', '\x19', '\x3', '\x1A', '\x3', + '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', + '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', + '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', + '\x1B', '\x3', '\x1B', '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', + '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', + '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1D', '\x3', '\x1D', '\x3', + '\x1D', '\x3', '\x1D', '\x3', '\x1E', '\x3', '\x1E', '\x3', '\x1E', '\x3', + '\x1E', '\x3', '\x1E', '\x3', '\x1E', '\x3', '\x1E', '\x3', '\x1E', '\x3', + '\x1E', '\x3', '\x1E', '\x3', '\x1F', '\x3', '\x1F', '\x3', '\x1F', '\x3', + '\x1F', '\x3', '\x1F', '\x3', ' ', '\x3', ' ', '\x3', ' ', '\x3', ' ', + '\x3', ' ', '\x3', ' ', '\x3', ' ', '\x3', '!', '\x3', '!', '\x3', '!', + '\x3', '!', '\x3', '!', '\x3', '!', '\x3', '!', '\x3', '\"', '\x3', '\"', + '\x3', '\"', '\x3', '\"', '\x3', '#', '\x3', '#', '\x3', '#', '\x3', '#', + '\x3', '#', '\x3', '$', '\x3', '$', '\x3', '$', '\x3', '$', '\x3', '$', + '\x3', '$', '\x3', '%', '\x3', '%', '\x3', '%', '\x3', '%', '\x3', '%', + '\x3', '%', '\x3', '%', '\x3', '%', '\x3', '&', '\x3', '&', '\x3', '&', + '\x3', '&', '\x3', '&', '\x3', '&', '\x3', '&', '\x3', '&', '\x3', '\'', + '\x3', '\'', '\x3', '\'', '\x3', '\'', '\x3', '\'', '\x3', '\'', '\x3', + '\'', '\x3', '\'', '\x3', '\'', '\x3', '\'', '\x3', '(', '\x3', '(', '\x3', + '(', '\x3', '(', '\x3', '(', '\x3', '(', '\x3', '(', '\x3', '(', '\x3', + '(', '\x3', ')', '\x3', ')', '\x3', ')', '\x3', ')', '\x3', ')', '\x3', + ')', '\x3', ')', '\x3', '*', '\x3', '*', '\x3', '*', '\x3', '*', '\x3', + '*', '\x3', '*', '\x3', '*', '\x3', '*', '\x3', '*', '\x3', '+', '\x3', + '+', '\x3', '+', '\x3', '+', '\x3', '+', '\x3', '+', '\x3', '+', '\x3', + ',', '\x3', ',', '\x3', ',', '\x3', ',', '\x3', ',', '\x3', ',', '\x3', + '-', '\x3', '-', '\x3', '-', '\x3', '-', '\x3', '-', '\x3', '-', '\x3', + '-', '\x3', '.', '\x3', '.', '\x3', '.', '\x3', '.', '\x3', '.', '\x3', + '.', '\x3', '.', '\x3', '.', '\x3', '.', '\x3', '/', '\x3', '/', '\x3', + '/', '\x3', '/', '\x3', '/', '\x3', '/', '\x3', '\x30', '\x3', '\x30', + '\x3', '\x30', '\x3', '\x30', '\x3', '\x30', '\x3', '\x30', '\x3', '\x30', + '\x3', '\x31', '\x3', '\x31', '\x3', '\x31', '\x3', '\x31', '\x3', '\x31', + '\x3', '\x31', '\x3', '\x31', '\x3', '\x31', '\x3', '\x31', '\x3', '\x31', + '\x3', '\x31', '\x3', '\x31', '\x3', '\x31', '\x3', '\x32', '\x3', '\x32', + '\x3', '\x32', '\x3', '\x32', '\x3', '\x32', '\x3', '\x33', '\x3', '\x33', + '\x3', '\x33', '\x3', '\x33', '\x3', '\x33', '\x3', '\x33', '\x3', '\x34', + '\x3', '\x34', '\x3', '\x34', '\x3', '\x34', '\x3', '\x34', '\x3', '\x34', + '\x3', '\x34', '\x3', '\x35', '\x3', '\x35', '\x3', '\x35', '\x3', '\x36', + '\x3', '\x36', '\x3', '\x36', '\x3', '\x36', '\x3', '\x36', '\x3', '\x36', + '\x3', '\x36', '\x3', '\x36', '\x3', '\x36', '\x3', '\x36', '\x3', '\x37', + '\x3', '\x37', '\x3', '\x37', '\x3', '\x37', '\x3', '\x37', '\x3', '\x37', + '\x3', '\x37', '\x3', '\x37', '\x3', '\x37', '\x3', '\x37', '\x3', '\x37', + '\x3', '\x38', '\x3', '\x38', '\x3', '\x38', '\x3', '\x38', '\x3', '\x39', + '\x3', '\x39', '\x3', '\x39', '\x3', '\x39', '\x3', '\x39', '\x3', ':', + '\x3', ':', '\x3', ':', '\x3', ':', '\x3', ':', '\x3', ';', '\x3', ';', + '\x3', ';', '\x3', ';', '\x3', ';', '\x3', ';', '\x3', ';', '\x3', ';', + '\x3', ';', '\x3', '<', '\x3', '<', '\x3', '<', '\x3', '<', '\x3', '<', + '\x3', '<', '\x3', '=', '\x3', '=', '\x3', '=', '\x3', '=', '\x3', '=', + '\x3', '>', '\x3', '>', '\x3', '?', '\x3', '?', '\x3', '?', '\x3', '?', + '\x5', '?', '\x2E9', '\n', '?', '\x3', '@', '\x3', '@', '\x5', '@', '\x2ED', + '\n', '@', '\x3', '\x41', '\x3', '\x41', '\x5', '\x41', '\x2F1', '\n', + '\x41', '\x3', '\x42', '\x3', '\x42', '\x5', '\x42', '\x2F5', '\n', '\x42', + '\x3', '\x43', '\x3', '\x43', '\x5', '\x43', '\x2F9', '\n', '\x43', '\x3', + '\x44', '\x3', '\x44', '\x3', '\x45', '\x3', '\x45', '\x3', '\x45', '\x5', + '\x45', '\x300', '\n', '\x45', '\x3', '\x45', '\x3', '\x45', '\x3', '\x45', + '\x5', '\x45', '\x305', '\n', '\x45', '\x5', '\x45', '\x307', '\n', '\x45', + '\x3', '\x46', '\x3', '\x46', '\x5', '\x46', '\x30B', '\n', '\x46', '\x3', + '\x46', '\x5', '\x46', '\x30E', '\n', '\x46', '\x3', 'G', '\x3', 'G', + '\x5', 'G', '\x312', '\n', 'G', '\x3', 'H', '\x3', 'H', '\x3', 'I', '\x6', + 'I', '\x317', '\n', 'I', '\r', 'I', '\xE', 'I', '\x318', '\x3', 'J', '\x3', + 'J', '\x5', 'J', '\x31D', '\n', 'J', '\x3', 'K', '\x6', 'K', '\x320', + '\n', 'K', '\r', 'K', '\xE', 'K', '\x321', '\x3', 'L', '\x3', 'L', '\x3', + 'L', '\x3', 'L', '\x3', 'M', '\x3', 'M', '\x5', 'M', '\x32A', '\n', 'M', + '\x3', 'M', '\x5', 'M', '\x32D', '\n', 'M', '\x3', 'N', '\x3', 'N', '\x3', + 'O', '\x6', 'O', '\x332', '\n', 'O', '\r', 'O', '\xE', 'O', '\x333', '\x3', + 'P', '\x3', 'P', '\x5', 'P', '\x338', '\n', 'P', '\x3', 'Q', '\x3', 'Q', + '\x5', 'Q', '\x33C', '\n', 'Q', '\x3', 'Q', '\x3', 'Q', '\x3', 'R', '\x3', + 'R', '\x5', 'R', '\x342', '\n', 'R', '\x3', 'R', '\x5', 'R', '\x345', + '\n', 'R', '\x3', 'S', '\x3', 'S', '\x3', 'T', '\x6', 'T', '\x34A', '\n', + 'T', '\r', 'T', '\xE', 'T', '\x34B', '\x3', 'U', '\x3', 'U', '\x5', 'U', + '\x350', '\n', 'U', '\x3', 'V', '\x3', 'V', '\x3', 'V', '\x3', 'V', '\x3', + 'W', '\x3', 'W', '\x5', 'W', '\x358', '\n', 'W', '\x3', 'W', '\x5', 'W', + '\x35B', '\n', 'W', '\x3', 'X', '\x3', 'X', '\x3', 'Y', '\x6', 'Y', '\x360', + '\n', 'Y', '\r', 'Y', '\xE', 'Y', '\x361', '\x3', 'Z', '\x3', 'Z', '\x5', + 'Z', '\x366', '\n', 'Z', '\x3', '[', '\x3', '[', '\x5', '[', '\x36A', + '\n', '[', '\x3', '\\', '\x3', '\\', '\x3', '\\', '\x5', '\\', '\x36F', + '\n', '\\', '\x3', '\\', '\x5', '\\', '\x372', '\n', '\\', '\x3', '\\', + '\x5', '\\', '\x375', '\n', '\\', '\x3', '\\', '\x3', '\\', '\x3', '\\', + '\x5', '\\', '\x37A', '\n', '\\', '\x3', '\\', '\x5', '\\', '\x37D', '\n', + '\\', '\x3', '\\', '\x3', '\\', '\x3', '\\', '\x5', '\\', '\x382', '\n', + '\\', '\x3', '\\', '\x3', '\\', '\x3', '\\', '\x5', '\\', '\x387', '\n', + '\\', '\x3', ']', '\x3', ']', '\x3', ']', '\x3', '^', '\x3', '^', '\x3', + '_', '\x5', '_', '\x38F', '\n', '_', '\x3', '_', '\x3', '_', '\x3', '`', + '\x3', '`', '\x3', '\x61', '\x3', '\x61', '\x3', '\x62', '\x3', '\x62', + '\x3', '\x62', '\x5', '\x62', '\x39A', '\n', '\x62', '\x3', '\x63', '\x3', + '\x63', '\x5', '\x63', '\x39E', '\n', '\x63', '\x3', '\x63', '\x3', '\x63', + '\x3', '\x63', '\x5', '\x63', '\x3A3', '\n', '\x63', '\x3', '\x63', '\x3', + '\x63', '\x5', '\x63', '\x3A7', '\n', '\x63', '\x3', '\x64', '\x3', '\x64', + '\x3', '\x64', '\x3', '\x65', '\x3', '\x65', '\x3', '\x66', '\x3', '\x66', + '\x3', '\x66', '\x3', '\x66', '\x3', '\x66', '\x3', '\x66', '\x3', '\x66', + '\x3', '\x66', '\x3', '\x66', '\x5', '\x66', '\x3B7', '\n', '\x66', '\x3', + 'g', '\x3', 'g', '\x3', 'g', '\x3', 'g', '\x3', 'g', '\x3', 'g', '\x3', + 'g', '\x3', 'g', '\x5', 'g', '\x3C1', '\n', 'g', '\x3', 'h', '\x3', 'h', + '\x3', 'i', '\x3', 'i', '\x5', 'i', '\x3C7', '\n', 'i', '\x3', 'i', '\x3', + 'i', '\x3', 'j', '\x6', 'j', '\x3CC', '\n', 'j', '\r', 'j', '\xE', 'j', + '\x3CD', '\x3', 'k', '\x3', 'k', '\x5', 'k', '\x3D2', '\n', 'k', '\x3', + 'l', '\x3', 'l', '\x3', 'l', '\x3', 'l', '\x5', 'l', '\x3D8', '\n', 'l', + '\x3', 'm', '\x3', 'm', '\x3', 'm', '\x3', 'm', '\x3', 'm', '\x3', 'm', + '\x3', 'm', '\x3', 'm', '\x3', 'm', '\x3', 'm', '\x3', 'm', '\x5', 'm', + '\x3E5', '\n', 'm', '\x3', 'n', '\x3', 'n', '\x3', 'o', '\x3', 'o', '\x6', + 'o', '\x3EB', '\n', 'o', '\r', 'o', '\xE', 'o', '\x3EC', '\x3', 'o', '\x3', + 'o', '\x3', 'o', '\x3', 'o', '\x3', 'o', '\x3', 'p', '\x3', 'p', '\x3', + 'p', '\x3', 'p', '\x3', 'p', '\x3', 'q', '\x3', 'q', '\x3', 'r', '\x3', + 'r', '\x3', 's', '\x3', 's', '\x3', 't', '\x3', 't', '\x3', 'u', '\x3', + 'u', '\x3', 'v', '\x3', 'v', '\x3', 'w', '\x3', 'w', '\x3', 'x', '\x3', + 'x', '\x3', 'y', '\x3', 'y', '\x3', 'z', '\x3', 'z', '\x3', 'z', '\x3', + 'z', '\x3', '{', '\x3', '{', '\x3', '|', '\x3', '|', '\x3', '|', '\x3', + '}', '\x3', '}', '\x3', '~', '\x3', '~', '\x3', '\x7F', '\x3', '\x7F', + '\x3', '\x80', '\x3', '\x80', '\x3', '\x81', '\x3', '\x81', '\x3', '\x82', + '\x3', '\x82', '\x3', '\x83', '\x3', '\x83', '\x3', '\x84', '\x3', '\x84', + '\x3', '\x84', '\x3', '\x85', '\x3', '\x85', '\x3', '\x85', '\x3', '\x86', + '\x3', '\x86', '\x3', '\x86', '\x3', '\x87', '\x3', '\x87', '\x3', '\x87', + '\x3', '\x88', '\x3', '\x88', '\x3', '\x88', '\x3', '\x89', '\x3', '\x89', + '\x3', '\x89', '\x3', '\x8A', '\x3', '\x8A', '\x3', '\x8A', '\x3', '\x8B', + '\x3', '\x8B', '\x3', '\x8B', '\x3', '\x8C', '\x3', '\x8C', '\x3', '\x8C', + '\x3', '\x8D', '\x3', '\x8D', '\x3', '\x8E', '\x3', '\x8E', '\x3', '\x8F', + '\x3', '\x8F', '\x3', '\x90', '\x3', '\x90', '\x3', '\x91', '\x3', '\x91', + '\x3', '\x92', '\x3', '\x92', '\x3', '\x93', '\x3', '\x93', '\x3', '\x94', + '\x3', '\x94', '\x3', '\x95', '\x3', '\x95', '\x3', '\x95', '\x3', '\x96', + '\x3', '\x96', '\x3', '\x96', '\x3', '\x97', '\x3', '\x97', '\x3', '\x97', + '\x3', '\x98', '\x3', '\x98', '\x3', '\x98', '\x3', '\x99', '\x3', '\x99', + '\x3', '\x99', '\x3', '\x9A', '\x3', '\x9A', '\x3', '\x9A', '\x3', '\x9B', + '\x3', '\x9B', '\x3', '\x9B', '\x3', '\x9C', '\x3', '\x9C', '\x3', '\x9C', + '\x3', '\x9D', '\x3', '\x9D', '\x3', '\x9D', '\x3', '\x9D', '\x3', '\x9E', + '\x3', '\x9E', '\x3', '\x9E', '\x3', '\x9E', '\x3', '\x9F', '\x3', '\x9F', + '\x3', '\x9F', '\x3', '\x9F', '\x3', '\x9F', '\x3', '\xA0', '\x3', '\xA0', + '\a', '\xA0', '\x474', '\n', '\xA0', '\f', '\xA0', '\xE', '\xA0', '\x477', + '\v', '\xA0', '\x3', '\xA1', '\x3', '\xA1', '\x3', '\xA1', '\x3', '\xA1', + '\x3', '\xA1', '\x3', '\xA1', '\x5', '\xA1', '\x47F', '\n', '\xA1', '\x3', + '\xA2', '\x3', '\xA2', '\x3', '\xA2', '\x3', '\xA2', '\x3', '\xA2', '\x3', + '\xA2', '\x5', '\xA2', '\x487', '\n', '\xA2', '\x3', '\xA3', '\x6', '\xA3', + '\x48A', '\n', '\xA3', '\r', '\xA3', '\xE', '\xA3', '\x48B', '\x3', '\xA3', + '\x3', '\xA3', '\x3', '\xA4', '\x3', '\xA4', '\x3', '\xA4', '\x3', '\xA4', + '\a', '\xA4', '\x494', '\n', '\xA4', '\f', '\xA4', '\xE', '\xA4', '\x497', + '\v', '\xA4', '\x3', '\xA4', '\x3', '\xA4', '\x3', '\xA4', '\x3', '\xA4', + '\x3', '\xA4', '\x3', '\xA5', '\x3', '\xA5', '\x3', '\xA5', '\x3', '\xA5', + '\a', '\xA5', '\x4A2', '\n', '\xA5', '\f', '\xA5', '\xE', '\xA5', '\x4A5', + '\v', '\xA5', '\x3', '\xA5', '\x3', '\xA5', '\x3', '\x495', '\x2', '\xA6', + '\x3', '\x3', '\x5', '\x4', '\a', '\x5', '\t', '\x6', '\v', '\a', '\r', + '\b', '\xF', '\t', '\x11', '\n', '\x13', '\v', '\x15', '\f', '\x17', '\r', + '\x19', '\xE', '\x1B', '\xF', '\x1D', '\x10', '\x1F', '\x11', '!', '\x12', + '#', '\x13', '%', '\x14', '\'', '\x15', ')', '\x16', '+', '\x17', '-', + '\x18', '/', '\x19', '\x31', '\x1A', '\x33', '\x1B', '\x35', '\x1C', '\x37', + '\x1D', '\x39', '\x1E', ';', '\x1F', '=', ' ', '?', '!', '\x41', '\"', + '\x43', '#', '\x45', '$', 'G', '%', 'I', '&', 'K', '\'', 'M', '(', 'O', + ')', 'Q', '*', 'S', '+', 'U', ',', 'W', '-', 'Y', '.', '[', '/', ']', + '\x30', '_', '\x31', '\x61', '\x32', '\x63', '\x33', '\x65', '\x34', 'g', + '\x35', 'i', '\x36', 'k', '\x37', 'm', '\x38', 'o', '\x39', 'q', ':', + 's', ';', 'u', '<', 'w', '=', 'y', '>', '{', '?', '}', '@', '\x7F', '\x2', + '\x81', '\x2', '\x83', '\x2', '\x85', '\x2', '\x87', '\x2', '\x89', '\x2', + '\x8B', '\x2', '\x8D', '\x2', '\x8F', '\x2', '\x91', '\x2', '\x93', '\x2', + '\x95', '\x2', '\x97', '\x2', '\x99', '\x2', '\x9B', '\x2', '\x9D', '\x2', + '\x9F', '\x2', '\xA1', '\x2', '\xA3', '\x2', '\xA5', '\x2', '\xA7', '\x2', + '\xA9', '\x2', '\xAB', '\x2', '\xAD', '\x2', '\xAF', '\x2', '\xB1', '\x2', + '\xB3', '\x2', '\xB5', '\x41', '\xB7', '\x2', '\xB9', '\x2', '\xBB', '\x2', + '\xBD', '\x2', '\xBF', '\x2', '\xC1', '\x2', '\xC3', '\x2', '\xC5', '\x2', + '\xC7', '\x2', '\xC9', '\x2', '\xCB', '\x42', '\xCD', '\x43', '\xCF', + '\x2', '\xD1', '\x44', '\xD3', '\x2', '\xD5', '\x2', '\xD7', '\x2', '\xD9', + '\x2', '\xDB', '\x2', '\xDD', '\x2', '\xDF', '\x45', '\xE1', '\x46', '\xE3', + 'G', '\xE5', 'H', '\xE7', 'I', '\xE9', 'J', '\xEB', 'K', '\xED', 'L', + '\xEF', 'M', '\xF1', 'N', '\xF3', 'O', '\xF5', 'P', '\xF7', 'Q', '\xF9', + 'R', '\xFB', 'S', '\xFD', 'T', '\xFF', 'U', '\x101', 'V', '\x103', 'W', + '\x105', 'X', '\x107', 'Y', '\x109', 'Z', '\x10B', '[', '\x10D', '\\', + '\x10F', ']', '\x111', '^', '\x113', '_', '\x115', '`', '\x117', '\x61', + '\x119', '\x62', '\x11B', '\x63', '\x11D', '\x64', '\x11F', '\x65', '\x121', + '\x66', '\x123', 'g', '\x125', 'h', '\x127', 'i', '\x129', 'j', '\x12B', + 'k', '\x12D', 'l', '\x12F', 'm', '\x131', 'n', '\x133', 'o', '\x135', + 'p', '\x137', 'q', '\x139', 'r', '\x13B', 's', '\x13D', 't', '\x13F', + 'u', '\x141', '\x2', '\x143', '\x2', '\x145', 'v', '\x147', 'w', '\x149', + 'x', '\x3', '\x2', '\x18', '\x4', '\x2', 'N', 'N', 'n', 'n', '\x3', '\x2', + '\x33', ';', '\x4', '\x2', 'Z', 'Z', 'z', 'z', '\x5', '\x2', '\x32', ';', + '\x43', 'H', '\x63', 'h', '\x3', '\x2', '\x32', '\x39', '\x4', '\x2', + '\x44', '\x44', '\x64', '\x64', '\x3', '\x2', '\x32', '\x33', '\x4', '\x2', + 'G', 'G', 'g', 'g', '\x4', '\x2', '-', '-', '/', '/', '\x6', '\x2', '\x46', + '\x46', 'H', 'H', '\x66', '\x66', 'h', 'h', '\x4', '\x2', 'R', 'R', 'r', + 'r', '\x6', '\x2', '\f', '\f', '\xF', '\xF', ')', ')', '^', '^', '\x6', + '\x2', '\f', '\f', '\xF', '\xF', '$', '$', '^', '^', '\n', '\x2', '$', + '$', ')', ')', '^', '^', '\x64', '\x64', 'h', 'h', 'p', 'p', 't', 't', + 'v', 'v', '\x3', '\x2', '\x32', '\x35', '\x6', '\x2', '&', '&', '\x43', + '\\', '\x61', '\x61', '\x63', '|', '\x4', '\x2', '\x2', '\x81', '\xD802', + '\xDC01', '\x3', '\x2', '\xD802', '\xDC01', '\x3', '\x2', '\xDC02', '\xE001', + '\a', '\x2', '&', '&', '\x32', ';', '\x43', '\\', '\x61', '\x61', '\x63', + '|', '\x5', '\x2', '\v', '\f', '\xE', '\xF', '\"', '\"', '\x4', '\x2', + '\f', '\f', '\xF', '\xF', '\x2', '\x4B7', '\x2', '\x3', '\x3', '\x2', + '\x2', '\x2', '\x2', '\x5', '\x3', '\x2', '\x2', '\x2', '\x2', '\a', '\x3', + '\x2', '\x2', '\x2', '\x2', '\t', '\x3', '\x2', '\x2', '\x2', '\x2', '\v', + '\x3', '\x2', '\x2', '\x2', '\x2', '\r', '\x3', '\x2', '\x2', '\x2', '\x2', + '\xF', '\x3', '\x2', '\x2', '\x2', '\x2', '\x11', '\x3', '\x2', '\x2', + '\x2', '\x2', '\x13', '\x3', '\x2', '\x2', '\x2', '\x2', '\x15', '\x3', + '\x2', '\x2', '\x2', '\x2', '\x17', '\x3', '\x2', '\x2', '\x2', '\x2', + '\x19', '\x3', '\x2', '\x2', '\x2', '\x2', '\x1B', '\x3', '\x2', '\x2', + '\x2', '\x2', '\x1D', '\x3', '\x2', '\x2', '\x2', '\x2', '\x1F', '\x3', + '\x2', '\x2', '\x2', '\x2', '!', '\x3', '\x2', '\x2', '\x2', '\x2', '#', + '\x3', '\x2', '\x2', '\x2', '\x2', '%', '\x3', '\x2', '\x2', '\x2', '\x2', + '\'', '\x3', '\x2', '\x2', '\x2', '\x2', ')', '\x3', '\x2', '\x2', '\x2', + '\x2', '+', '\x3', '\x2', '\x2', '\x2', '\x2', '-', '\x3', '\x2', '\x2', + '\x2', '\x2', '/', '\x3', '\x2', '\x2', '\x2', '\x2', '\x31', '\x3', '\x2', + '\x2', '\x2', '\x2', '\x33', '\x3', '\x2', '\x2', '\x2', '\x2', '\x35', + '\x3', '\x2', '\x2', '\x2', '\x2', '\x37', '\x3', '\x2', '\x2', '\x2', + '\x2', '\x39', '\x3', '\x2', '\x2', '\x2', '\x2', ';', '\x3', '\x2', '\x2', + '\x2', '\x2', '=', '\x3', '\x2', '\x2', '\x2', '\x2', '?', '\x3', '\x2', + '\x2', '\x2', '\x2', '\x41', '\x3', '\x2', '\x2', '\x2', '\x2', '\x43', + '\x3', '\x2', '\x2', '\x2', '\x2', '\x45', '\x3', '\x2', '\x2', '\x2', + '\x2', 'G', '\x3', '\x2', '\x2', '\x2', '\x2', 'I', '\x3', '\x2', '\x2', + '\x2', '\x2', 'K', '\x3', '\x2', '\x2', '\x2', '\x2', 'M', '\x3', '\x2', + '\x2', '\x2', '\x2', 'O', '\x3', '\x2', '\x2', '\x2', '\x2', 'Q', '\x3', + '\x2', '\x2', '\x2', '\x2', 'S', '\x3', '\x2', '\x2', '\x2', '\x2', 'U', + '\x3', '\x2', '\x2', '\x2', '\x2', 'W', '\x3', '\x2', '\x2', '\x2', '\x2', + 'Y', '\x3', '\x2', '\x2', '\x2', '\x2', '[', '\x3', '\x2', '\x2', '\x2', + '\x2', ']', '\x3', '\x2', '\x2', '\x2', '\x2', '_', '\x3', '\x2', '\x2', + '\x2', '\x2', '\x61', '\x3', '\x2', '\x2', '\x2', '\x2', '\x63', '\x3', + '\x2', '\x2', '\x2', '\x2', '\x65', '\x3', '\x2', '\x2', '\x2', '\x2', + 'g', '\x3', '\x2', '\x2', '\x2', '\x2', 'i', '\x3', '\x2', '\x2', '\x2', + '\x2', 'k', '\x3', '\x2', '\x2', '\x2', '\x2', 'm', '\x3', '\x2', '\x2', + '\x2', '\x2', 'o', '\x3', '\x2', '\x2', '\x2', '\x2', 'q', '\x3', '\x2', + '\x2', '\x2', '\x2', 's', '\x3', '\x2', '\x2', '\x2', '\x2', 'u', '\x3', + '\x2', '\x2', '\x2', '\x2', 'w', '\x3', '\x2', '\x2', '\x2', '\x2', 'y', + '\x3', '\x2', '\x2', '\x2', '\x2', '{', '\x3', '\x2', '\x2', '\x2', '\x2', + '}', '\x3', '\x2', '\x2', '\x2', '\x2', '\xB5', '\x3', '\x2', '\x2', '\x2', + '\x2', '\xCB', '\x3', '\x2', '\x2', '\x2', '\x2', '\xCD', '\x3', '\x2', + '\x2', '\x2', '\x2', '\xD1', '\x3', '\x2', '\x2', '\x2', '\x2', '\xDF', + '\x3', '\x2', '\x2', '\x2', '\x2', '\xE1', '\x3', '\x2', '\x2', '\x2', + '\x2', '\xE3', '\x3', '\x2', '\x2', '\x2', '\x2', '\xE5', '\x3', '\x2', + '\x2', '\x2', '\x2', '\xE7', '\x3', '\x2', '\x2', '\x2', '\x2', '\xE9', + '\x3', '\x2', '\x2', '\x2', '\x2', '\xEB', '\x3', '\x2', '\x2', '\x2', + '\x2', '\xED', '\x3', '\x2', '\x2', '\x2', '\x2', '\xEF', '\x3', '\x2', + '\x2', '\x2', '\x2', '\xF1', '\x3', '\x2', '\x2', '\x2', '\x2', '\xF3', + '\x3', '\x2', '\x2', '\x2', '\x2', '\xF5', '\x3', '\x2', '\x2', '\x2', + '\x2', '\xF7', '\x3', '\x2', '\x2', '\x2', '\x2', '\xF9', '\x3', '\x2', + '\x2', '\x2', '\x2', '\xFB', '\x3', '\x2', '\x2', '\x2', '\x2', '\xFD', + '\x3', '\x2', '\x2', '\x2', '\x2', '\xFF', '\x3', '\x2', '\x2', '\x2', + '\x2', '\x101', '\x3', '\x2', '\x2', '\x2', '\x2', '\x103', '\x3', '\x2', + '\x2', '\x2', '\x2', '\x105', '\x3', '\x2', '\x2', '\x2', '\x2', '\x107', + '\x3', '\x2', '\x2', '\x2', '\x2', '\x109', '\x3', '\x2', '\x2', '\x2', + '\x2', '\x10B', '\x3', '\x2', '\x2', '\x2', '\x2', '\x10D', '\x3', '\x2', + '\x2', '\x2', '\x2', '\x10F', '\x3', '\x2', '\x2', '\x2', '\x2', '\x111', + '\x3', '\x2', '\x2', '\x2', '\x2', '\x113', '\x3', '\x2', '\x2', '\x2', + '\x2', '\x115', '\x3', '\x2', '\x2', '\x2', '\x2', '\x117', '\x3', '\x2', + '\x2', '\x2', '\x2', '\x119', '\x3', '\x2', '\x2', '\x2', '\x2', '\x11B', + '\x3', '\x2', '\x2', '\x2', '\x2', '\x11D', '\x3', '\x2', '\x2', '\x2', + '\x2', '\x11F', '\x3', '\x2', '\x2', '\x2', '\x2', '\x121', '\x3', '\x2', + '\x2', '\x2', '\x2', '\x123', '\x3', '\x2', '\x2', '\x2', '\x2', '\x125', + '\x3', '\x2', '\x2', '\x2', '\x2', '\x127', '\x3', '\x2', '\x2', '\x2', + '\x2', '\x129', '\x3', '\x2', '\x2', '\x2', '\x2', '\x12B', '\x3', '\x2', + '\x2', '\x2', '\x2', '\x12D', '\x3', '\x2', '\x2', '\x2', '\x2', '\x12F', + '\x3', '\x2', '\x2', '\x2', '\x2', '\x131', '\x3', '\x2', '\x2', '\x2', + '\x2', '\x133', '\x3', '\x2', '\x2', '\x2', '\x2', '\x135', '\x3', '\x2', + '\x2', '\x2', '\x2', '\x137', '\x3', '\x2', '\x2', '\x2', '\x2', '\x139', + '\x3', '\x2', '\x2', '\x2', '\x2', '\x13B', '\x3', '\x2', '\x2', '\x2', + '\x2', '\x13D', '\x3', '\x2', '\x2', '\x2', '\x2', '\x13F', '\x3', '\x2', + '\x2', '\x2', '\x2', '\x145', '\x3', '\x2', '\x2', '\x2', '\x2', '\x147', + '\x3', '\x2', '\x2', '\x2', '\x2', '\x149', '\x3', '\x2', '\x2', '\x2', + '\x3', '\x14B', '\x3', '\x2', '\x2', '\x2', '\x5', '\x154', '\x3', '\x2', + '\x2', '\x2', '\a', '\x15B', '\x3', '\x2', '\x2', '\x2', '\t', '\x163', + '\x3', '\x2', '\x2', '\x2', '\v', '\x169', '\x3', '\x2', '\x2', '\x2', + '\r', '\x16E', '\x3', '\x2', '\x2', '\x2', '\xF', '\x173', '\x3', '\x2', + '\x2', '\x2', '\x11', '\x179', '\x3', '\x2', '\x2', '\x2', '\x13', '\x17E', + '\x3', '\x2', '\x2', '\x2', '\x15', '\x184', '\x3', '\x2', '\x2', '\x2', + '\x17', '\x18A', '\x3', '\x2', '\x2', '\x2', '\x19', '\x193', '\x3', '\x2', + '\x2', '\x2', '\x1B', '\x19B', '\x3', '\x2', '\x2', '\x2', '\x1D', '\x19E', + '\x3', '\x2', '\x2', '\x2', '\x1F', '\x1A5', '\x3', '\x2', '\x2', '\x2', + '!', '\x1AA', '\x3', '\x2', '\x2', '\x2', '#', '\x1AF', '\x3', '\x2', + '\x2', '\x2', '%', '\x1B7', '\x3', '\x2', '\x2', '\x2', '\'', '\x1BF', + '\x3', '\x2', '\x2', '\x2', ')', '\x1C5', '\x3', '\x2', '\x2', '\x2', + '+', '\x1CD', '\x3', '\x2', '\x2', '\x2', '-', '\x1D3', '\x3', '\x2', + '\x2', '\x2', '/', '\x1D7', '\x3', '\x2', '\x2', '\x2', '\x31', '\x1DA', + '\x3', '\x2', '\x2', '\x2', '\x33', '\x1DF', '\x3', '\x2', '\x2', '\x2', + '\x35', '\x1EA', '\x3', '\x2', '\x2', '\x2', '\x37', '\x1F1', '\x3', '\x2', + '\x2', '\x2', '\x39', '\x1FC', '\x3', '\x2', '\x2', '\x2', ';', '\x200', + '\x3', '\x2', '\x2', '\x2', '=', '\x20A', '\x3', '\x2', '\x2', '\x2', + '?', '\x20F', '\x3', '\x2', '\x2', '\x2', '\x41', '\x216', '\x3', '\x2', + '\x2', '\x2', '\x43', '\x21D', '\x3', '\x2', '\x2', '\x2', '\x45', '\x221', + '\x3', '\x2', '\x2', '\x2', 'G', '\x226', '\x3', '\x2', '\x2', '\x2', + 'I', '\x22C', '\x3', '\x2', '\x2', '\x2', 'K', '\x234', '\x3', '\x2', + '\x2', '\x2', 'M', '\x23C', '\x3', '\x2', '\x2', '\x2', 'O', '\x246', + '\x3', '\x2', '\x2', '\x2', 'Q', '\x24F', '\x3', '\x2', '\x2', '\x2', + 'S', '\x256', '\x3', '\x2', '\x2', '\x2', 'U', '\x25F', '\x3', '\x2', + '\x2', '\x2', 'W', '\x266', '\x3', '\x2', '\x2', '\x2', 'Y', '\x26C', + '\x3', '\x2', '\x2', '\x2', '[', '\x273', '\x3', '\x2', '\x2', '\x2', + ']', '\x27C', '\x3', '\x2', '\x2', '\x2', '_', '\x282', '\x3', '\x2', + '\x2', '\x2', '\x61', '\x289', '\x3', '\x2', '\x2', '\x2', '\x63', '\x296', + '\x3', '\x2', '\x2', '\x2', '\x65', '\x29B', '\x3', '\x2', '\x2', '\x2', + 'g', '\x2A1', '\x3', '\x2', '\x2', '\x2', 'i', '\x2A8', '\x3', '\x2', + '\x2', '\x2', 'k', '\x2AB', '\x3', '\x2', '\x2', '\x2', 'm', '\x2B5', + '\x3', '\x2', '\x2', '\x2', 'o', '\x2C0', '\x3', '\x2', '\x2', '\x2', + 'q', '\x2C4', '\x3', '\x2', '\x2', '\x2', 's', '\x2C9', '\x3', '\x2', + '\x2', '\x2', 'u', '\x2CE', '\x3', '\x2', '\x2', '\x2', 'w', '\x2D7', + '\x3', '\x2', '\x2', '\x2', 'y', '\x2DD', '\x3', '\x2', '\x2', '\x2', + '{', '\x2E2', '\x3', '\x2', '\x2', '\x2', '}', '\x2E8', '\x3', '\x2', + '\x2', '\x2', '\x7F', '\x2EA', '\x3', '\x2', '\x2', '\x2', '\x81', '\x2EE', + '\x3', '\x2', '\x2', '\x2', '\x83', '\x2F2', '\x3', '\x2', '\x2', '\x2', + '\x85', '\x2F6', '\x3', '\x2', '\x2', '\x2', '\x87', '\x2FA', '\x3', '\x2', + '\x2', '\x2', '\x89', '\x306', '\x3', '\x2', '\x2', '\x2', '\x8B', '\x308', + '\x3', '\x2', '\x2', '\x2', '\x8D', '\x311', '\x3', '\x2', '\x2', '\x2', + '\x8F', '\x313', '\x3', '\x2', '\x2', '\x2', '\x91', '\x316', '\x3', '\x2', + '\x2', '\x2', '\x93', '\x31C', '\x3', '\x2', '\x2', '\x2', '\x95', '\x31F', + '\x3', '\x2', '\x2', '\x2', '\x97', '\x323', '\x3', '\x2', '\x2', '\x2', + '\x99', '\x327', '\x3', '\x2', '\x2', '\x2', '\x9B', '\x32E', '\x3', '\x2', + '\x2', '\x2', '\x9D', '\x331', '\x3', '\x2', '\x2', '\x2', '\x9F', '\x337', + '\x3', '\x2', '\x2', '\x2', '\xA1', '\x339', '\x3', '\x2', '\x2', '\x2', + '\xA3', '\x33F', '\x3', '\x2', '\x2', '\x2', '\xA5', '\x346', '\x3', '\x2', + '\x2', '\x2', '\xA7', '\x349', '\x3', '\x2', '\x2', '\x2', '\xA9', '\x34F', + '\x3', '\x2', '\x2', '\x2', '\xAB', '\x351', '\x3', '\x2', '\x2', '\x2', + '\xAD', '\x355', '\x3', '\x2', '\x2', '\x2', '\xAF', '\x35C', '\x3', '\x2', + '\x2', '\x2', '\xB1', '\x35F', '\x3', '\x2', '\x2', '\x2', '\xB3', '\x365', + '\x3', '\x2', '\x2', '\x2', '\xB5', '\x369', '\x3', '\x2', '\x2', '\x2', + '\xB7', '\x386', '\x3', '\x2', '\x2', '\x2', '\xB9', '\x388', '\x3', '\x2', + '\x2', '\x2', '\xBB', '\x38B', '\x3', '\x2', '\x2', '\x2', '\xBD', '\x38E', + '\x3', '\x2', '\x2', '\x2', '\xBF', '\x392', '\x3', '\x2', '\x2', '\x2', + '\xC1', '\x394', '\x3', '\x2', '\x2', '\x2', '\xC3', '\x396', '\x3', '\x2', + '\x2', '\x2', '\xC5', '\x3A6', '\x3', '\x2', '\x2', '\x2', '\xC7', '\x3A8', + '\x3', '\x2', '\x2', '\x2', '\xC9', '\x3AB', '\x3', '\x2', '\x2', '\x2', + '\xCB', '\x3B6', '\x3', '\x2', '\x2', '\x2', '\xCD', '\x3C0', '\x3', '\x2', + '\x2', '\x2', '\xCF', '\x3C2', '\x3', '\x2', '\x2', '\x2', '\xD1', '\x3C4', + '\x3', '\x2', '\x2', '\x2', '\xD3', '\x3CB', '\x3', '\x2', '\x2', '\x2', + '\xD5', '\x3D1', '\x3', '\x2', '\x2', '\x2', '\xD7', '\x3D7', '\x3', '\x2', + '\x2', '\x2', '\xD9', '\x3E4', '\x3', '\x2', '\x2', '\x2', '\xDB', '\x3E6', + '\x3', '\x2', '\x2', '\x2', '\xDD', '\x3E8', '\x3', '\x2', '\x2', '\x2', + '\xDF', '\x3F3', '\x3', '\x2', '\x2', '\x2', '\xE1', '\x3F8', '\x3', '\x2', + '\x2', '\x2', '\xE3', '\x3FA', '\x3', '\x2', '\x2', '\x2', '\xE5', '\x3FC', + '\x3', '\x2', '\x2', '\x2', '\xE7', '\x3FE', '\x3', '\x2', '\x2', '\x2', + '\xE9', '\x400', '\x3', '\x2', '\x2', '\x2', '\xEB', '\x402', '\x3', '\x2', + '\x2', '\x2', '\xED', '\x404', '\x3', '\x2', '\x2', '\x2', '\xEF', '\x406', + '\x3', '\x2', '\x2', '\x2', '\xF1', '\x408', '\x3', '\x2', '\x2', '\x2', + '\xF3', '\x40A', '\x3', '\x2', '\x2', '\x2', '\xF5', '\x40E', '\x3', '\x2', + '\x2', '\x2', '\xF7', '\x410', '\x3', '\x2', '\x2', '\x2', '\xF9', '\x413', + '\x3', '\x2', '\x2', '\x2', '\xFB', '\x415', '\x3', '\x2', '\x2', '\x2', + '\xFD', '\x417', '\x3', '\x2', '\x2', '\x2', '\xFF', '\x419', '\x3', '\x2', + '\x2', '\x2', '\x101', '\x41B', '\x3', '\x2', '\x2', '\x2', '\x103', '\x41D', + '\x3', '\x2', '\x2', '\x2', '\x105', '\x41F', '\x3', '\x2', '\x2', '\x2', + '\x107', '\x421', '\x3', '\x2', '\x2', '\x2', '\x109', '\x424', '\x3', + '\x2', '\x2', '\x2', '\x10B', '\x427', '\x3', '\x2', '\x2', '\x2', '\x10D', + '\x42A', '\x3', '\x2', '\x2', '\x2', '\x10F', '\x42D', '\x3', '\x2', '\x2', + '\x2', '\x111', '\x430', '\x3', '\x2', '\x2', '\x2', '\x113', '\x433', + '\x3', '\x2', '\x2', '\x2', '\x115', '\x436', '\x3', '\x2', '\x2', '\x2', + '\x117', '\x439', '\x3', '\x2', '\x2', '\x2', '\x119', '\x43C', '\x3', + '\x2', '\x2', '\x2', '\x11B', '\x43E', '\x3', '\x2', '\x2', '\x2', '\x11D', + '\x440', '\x3', '\x2', '\x2', '\x2', '\x11F', '\x442', '\x3', '\x2', '\x2', + '\x2', '\x121', '\x444', '\x3', '\x2', '\x2', '\x2', '\x123', '\x446', + '\x3', '\x2', '\x2', '\x2', '\x125', '\x448', '\x3', '\x2', '\x2', '\x2', + '\x127', '\x44A', '\x3', '\x2', '\x2', '\x2', '\x129', '\x44C', '\x3', + '\x2', '\x2', '\x2', '\x12B', '\x44F', '\x3', '\x2', '\x2', '\x2', '\x12D', + '\x452', '\x3', '\x2', '\x2', '\x2', '\x12F', '\x455', '\x3', '\x2', '\x2', + '\x2', '\x131', '\x458', '\x3', '\x2', '\x2', '\x2', '\x133', '\x45B', + '\x3', '\x2', '\x2', '\x2', '\x135', '\x45E', '\x3', '\x2', '\x2', '\x2', + '\x137', '\x461', '\x3', '\x2', '\x2', '\x2', '\x139', '\x464', '\x3', + '\x2', '\x2', '\x2', '\x13B', '\x468', '\x3', '\x2', '\x2', '\x2', '\x13D', + '\x46C', '\x3', '\x2', '\x2', '\x2', '\x13F', '\x471', '\x3', '\x2', '\x2', + '\x2', '\x141', '\x47E', '\x3', '\x2', '\x2', '\x2', '\x143', '\x486', + '\x3', '\x2', '\x2', '\x2', '\x145', '\x489', '\x3', '\x2', '\x2', '\x2', + '\x147', '\x48F', '\x3', '\x2', '\x2', '\x2', '\x149', '\x49D', '\x3', + '\x2', '\x2', '\x2', '\x14B', '\x14C', '\a', '\x63', '\x2', '\x2', '\x14C', + '\x14D', '\a', '\x64', '\x2', '\x2', '\x14D', '\x14E', '\a', 'u', '\x2', + '\x2', '\x14E', '\x14F', '\a', 'v', '\x2', '\x2', '\x14F', '\x150', '\a', + 't', '\x2', '\x2', '\x150', '\x151', '\a', '\x63', '\x2', '\x2', '\x151', + '\x152', '\a', '\x65', '\x2', '\x2', '\x152', '\x153', '\a', 'v', '\x2', + '\x2', '\x153', '\x4', '\x3', '\x2', '\x2', '\x2', '\x154', '\x155', '\a', + '\x63', '\x2', '\x2', '\x155', '\x156', '\a', 'u', '\x2', '\x2', '\x156', + '\x157', '\a', 'u', '\x2', '\x2', '\x157', '\x158', '\a', 'g', '\x2', + '\x2', '\x158', '\x159', '\a', 't', '\x2', '\x2', '\x159', '\x15A', '\a', + 'v', '\x2', '\x2', '\x15A', '\x6', '\x3', '\x2', '\x2', '\x2', '\x15B', + '\x15C', '\a', '\x64', '\x2', '\x2', '\x15C', '\x15D', '\a', 'q', '\x2', + '\x2', '\x15D', '\x15E', '\a', 'q', '\x2', '\x2', '\x15E', '\x15F', '\a', + 'n', '\x2', '\x2', '\x15F', '\x160', '\a', 'g', '\x2', '\x2', '\x160', + '\x161', '\a', '\x63', '\x2', '\x2', '\x161', '\x162', '\a', 'p', '\x2', + '\x2', '\x162', '\b', '\x3', '\x2', '\x2', '\x2', '\x163', '\x164', '\a', + '\x64', '\x2', '\x2', '\x164', '\x165', '\a', 't', '\x2', '\x2', '\x165', + '\x166', '\a', 'g', '\x2', '\x2', '\x166', '\x167', '\a', '\x63', '\x2', + '\x2', '\x167', '\x168', '\a', 'm', '\x2', '\x2', '\x168', '\n', '\x3', + '\x2', '\x2', '\x2', '\x169', '\x16A', '\a', '\x64', '\x2', '\x2', '\x16A', + '\x16B', '\a', '{', '\x2', '\x2', '\x16B', '\x16C', '\a', 'v', '\x2', + '\x2', '\x16C', '\x16D', '\a', 'g', '\x2', '\x2', '\x16D', '\f', '\x3', + '\x2', '\x2', '\x2', '\x16E', '\x16F', '\a', '\x65', '\x2', '\x2', '\x16F', + '\x170', '\a', '\x63', '\x2', '\x2', '\x170', '\x171', '\a', 'u', '\x2', + '\x2', '\x171', '\x172', '\a', 'g', '\x2', '\x2', '\x172', '\xE', '\x3', + '\x2', '\x2', '\x2', '\x173', '\x174', '\a', '\x65', '\x2', '\x2', '\x174', + '\x175', '\a', '\x63', '\x2', '\x2', '\x175', '\x176', '\a', 'v', '\x2', + '\x2', '\x176', '\x177', '\a', '\x65', '\x2', '\x2', '\x177', '\x178', + '\a', 'j', '\x2', '\x2', '\x178', '\x10', '\x3', '\x2', '\x2', '\x2', + '\x179', '\x17A', '\a', '\x65', '\x2', '\x2', '\x17A', '\x17B', '\a', + 'j', '\x2', '\x2', '\x17B', '\x17C', '\a', '\x63', '\x2', '\x2', '\x17C', + '\x17D', '\a', 't', '\x2', '\x2', '\x17D', '\x12', '\x3', '\x2', '\x2', + '\x2', '\x17E', '\x17F', '\a', '\x65', '\x2', '\x2', '\x17F', '\x180', + '\a', 'n', '\x2', '\x2', '\x180', '\x181', '\a', '\x63', '\x2', '\x2', + '\x181', '\x182', '\a', 'u', '\x2', '\x2', '\x182', '\x183', '\a', 'u', + '\x2', '\x2', '\x183', '\x14', '\x3', '\x2', '\x2', '\x2', '\x184', '\x185', + '\a', '\x65', '\x2', '\x2', '\x185', '\x186', '\a', 'q', '\x2', '\x2', + '\x186', '\x187', '\a', 'p', '\x2', '\x2', '\x187', '\x188', '\a', 'u', + '\x2', '\x2', '\x188', '\x189', '\a', 'v', '\x2', '\x2', '\x189', '\x16', + '\x3', '\x2', '\x2', '\x2', '\x18A', '\x18B', '\a', '\x65', '\x2', '\x2', + '\x18B', '\x18C', '\a', 'q', '\x2', '\x2', '\x18C', '\x18D', '\a', 'p', + '\x2', '\x2', '\x18D', '\x18E', '\a', 'v', '\x2', '\x2', '\x18E', '\x18F', + '\a', 'k', '\x2', '\x2', '\x18F', '\x190', '\a', 'p', '\x2', '\x2', '\x190', + '\x191', '\a', 'w', '\x2', '\x2', '\x191', '\x192', '\a', 'g', '\x2', + '\x2', '\x192', '\x18', '\x3', '\x2', '\x2', '\x2', '\x193', '\x194', + '\a', '\x66', '\x2', '\x2', '\x194', '\x195', '\a', 'g', '\x2', '\x2', + '\x195', '\x196', '\a', 'h', '\x2', '\x2', '\x196', '\x197', '\a', '\x63', + '\x2', '\x2', '\x197', '\x198', '\a', 'w', '\x2', '\x2', '\x198', '\x199', + '\a', 'n', '\x2', '\x2', '\x199', '\x19A', '\a', 'v', '\x2', '\x2', '\x19A', + '\x1A', '\x3', '\x2', '\x2', '\x2', '\x19B', '\x19C', '\a', '\x66', '\x2', + '\x2', '\x19C', '\x19D', '\a', 'q', '\x2', '\x2', '\x19D', '\x1C', '\x3', + '\x2', '\x2', '\x2', '\x19E', '\x19F', '\a', '\x66', '\x2', '\x2', '\x19F', + '\x1A0', '\a', 'q', '\x2', '\x2', '\x1A0', '\x1A1', '\a', 'w', '\x2', + '\x2', '\x1A1', '\x1A2', '\a', '\x64', '\x2', '\x2', '\x1A2', '\x1A3', + '\a', 'n', '\x2', '\x2', '\x1A3', '\x1A4', '\a', 'g', '\x2', '\x2', '\x1A4', + '\x1E', '\x3', '\x2', '\x2', '\x2', '\x1A5', '\x1A6', '\a', 'g', '\x2', + '\x2', '\x1A6', '\x1A7', '\a', 'n', '\x2', '\x2', '\x1A7', '\x1A8', '\a', + 'u', '\x2', '\x2', '\x1A8', '\x1A9', '\a', 'g', '\x2', '\x2', '\x1A9', + ' ', '\x3', '\x2', '\x2', '\x2', '\x1AA', '\x1AB', '\a', 'g', '\x2', '\x2', + '\x1AB', '\x1AC', '\a', 'p', '\x2', '\x2', '\x1AC', '\x1AD', '\a', 'w', + '\x2', '\x2', '\x1AD', '\x1AE', '\a', 'o', '\x2', '\x2', '\x1AE', '\"', + '\x3', '\x2', '\x2', '\x2', '\x1AF', '\x1B0', '\a', 'g', '\x2', '\x2', + '\x1B0', '\x1B1', '\a', 'z', '\x2', '\x2', '\x1B1', '\x1B2', '\a', 'r', + '\x2', '\x2', '\x1B2', '\x1B3', '\a', 'q', '\x2', '\x2', '\x1B3', '\x1B4', + '\a', 't', '\x2', '\x2', '\x1B4', '\x1B5', '\a', 'v', '\x2', '\x2', '\x1B5', + '\x1B6', '\a', 'u', '\x2', '\x2', '\x1B6', '$', '\x3', '\x2', '\x2', '\x2', + '\x1B7', '\x1B8', '\a', 'g', '\x2', '\x2', '\x1B8', '\x1B9', '\a', 'z', + '\x2', '\x2', '\x1B9', '\x1BA', '\a', 'v', '\x2', '\x2', '\x1BA', '\x1BB', + '\a', 'g', '\x2', '\x2', '\x1BB', '\x1BC', '\a', 'p', '\x2', '\x2', '\x1BC', + '\x1BD', '\a', '\x66', '\x2', '\x2', '\x1BD', '\x1BE', '\a', 'u', '\x2', + '\x2', '\x1BE', '&', '\x3', '\x2', '\x2', '\x2', '\x1BF', '\x1C0', '\a', + 'h', '\x2', '\x2', '\x1C0', '\x1C1', '\a', 'k', '\x2', '\x2', '\x1C1', + '\x1C2', '\a', 'p', '\x2', '\x2', '\x1C2', '\x1C3', '\a', '\x63', '\x2', + '\x2', '\x1C3', '\x1C4', '\a', 'n', '\x2', '\x2', '\x1C4', '(', '\x3', + '\x2', '\x2', '\x2', '\x1C5', '\x1C6', '\a', 'h', '\x2', '\x2', '\x1C6', + '\x1C7', '\a', 'k', '\x2', '\x2', '\x1C7', '\x1C8', '\a', 'p', '\x2', + '\x2', '\x1C8', '\x1C9', '\a', '\x63', '\x2', '\x2', '\x1C9', '\x1CA', + '\a', 'n', '\x2', '\x2', '\x1CA', '\x1CB', '\a', 'n', '\x2', '\x2', '\x1CB', + '\x1CC', '\a', '{', '\x2', '\x2', '\x1CC', '*', '\x3', '\x2', '\x2', '\x2', + '\x1CD', '\x1CE', '\a', 'h', '\x2', '\x2', '\x1CE', '\x1CF', '\a', 'n', + '\x2', '\x2', '\x1CF', '\x1D0', '\a', 'q', '\x2', '\x2', '\x1D0', '\x1D1', + '\a', '\x63', '\x2', '\x2', '\x1D1', '\x1D2', '\a', 'v', '\x2', '\x2', + '\x1D2', ',', '\x3', '\x2', '\x2', '\x2', '\x1D3', '\x1D4', '\a', 'h', + '\x2', '\x2', '\x1D4', '\x1D5', '\a', 'q', '\x2', '\x2', '\x1D5', '\x1D6', + '\a', 't', '\x2', '\x2', '\x1D6', '.', '\x3', '\x2', '\x2', '\x2', '\x1D7', + '\x1D8', '\a', 'k', '\x2', '\x2', '\x1D8', '\x1D9', '\a', 'h', '\x2', + '\x2', '\x1D9', '\x30', '\x3', '\x2', '\x2', '\x2', '\x1DA', '\x1DB', + '\a', 'i', '\x2', '\x2', '\x1DB', '\x1DC', '\a', 'q', '\x2', '\x2', '\x1DC', + '\x1DD', '\a', 'v', '\x2', '\x2', '\x1DD', '\x1DE', '\a', 'q', '\x2', + '\x2', '\x1DE', '\x32', '\x3', '\x2', '\x2', '\x2', '\x1DF', '\x1E0', + '\a', 'k', '\x2', '\x2', '\x1E0', '\x1E1', '\a', 'o', '\x2', '\x2', '\x1E1', + '\x1E2', '\a', 'r', '\x2', '\x2', '\x1E2', '\x1E3', '\a', 'n', '\x2', + '\x2', '\x1E3', '\x1E4', '\a', 'g', '\x2', '\x2', '\x1E4', '\x1E5', '\a', + 'o', '\x2', '\x2', '\x1E5', '\x1E6', '\a', 'g', '\x2', '\x2', '\x1E6', + '\x1E7', '\a', 'p', '\x2', '\x2', '\x1E7', '\x1E8', '\a', 'v', '\x2', + '\x2', '\x1E8', '\x1E9', '\a', 'u', '\x2', '\x2', '\x1E9', '\x34', '\x3', + '\x2', '\x2', '\x2', '\x1EA', '\x1EB', '\a', 'k', '\x2', '\x2', '\x1EB', + '\x1EC', '\a', 'o', '\x2', '\x2', '\x1EC', '\x1ED', '\a', 'r', '\x2', + '\x2', '\x1ED', '\x1EE', '\a', 'q', '\x2', '\x2', '\x1EE', '\x1EF', '\a', + 't', '\x2', '\x2', '\x1EF', '\x1F0', '\a', 'v', '\x2', '\x2', '\x1F0', + '\x36', '\x3', '\x2', '\x2', '\x2', '\x1F1', '\x1F2', '\a', 'k', '\x2', + '\x2', '\x1F2', '\x1F3', '\a', 'p', '\x2', '\x2', '\x1F3', '\x1F4', '\a', + 'u', '\x2', '\x2', '\x1F4', '\x1F5', '\a', 'v', '\x2', '\x2', '\x1F5', + '\x1F6', '\a', '\x63', '\x2', '\x2', '\x1F6', '\x1F7', '\a', 'p', '\x2', + '\x2', '\x1F7', '\x1F8', '\a', '\x65', '\x2', '\x2', '\x1F8', '\x1F9', + '\a', 'g', '\x2', '\x2', '\x1F9', '\x1FA', '\a', 'q', '\x2', '\x2', '\x1FA', + '\x1FB', '\a', 'h', '\x2', '\x2', '\x1FB', '\x38', '\x3', '\x2', '\x2', + '\x2', '\x1FC', '\x1FD', '\a', 'k', '\x2', '\x2', '\x1FD', '\x1FE', '\a', + 'p', '\x2', '\x2', '\x1FE', '\x1FF', '\a', 'v', '\x2', '\x2', '\x1FF', + ':', '\x3', '\x2', '\x2', '\x2', '\x200', '\x201', '\a', 'k', '\x2', '\x2', + '\x201', '\x202', '\a', 'p', '\x2', '\x2', '\x202', '\x203', '\a', 'v', + '\x2', '\x2', '\x203', '\x204', '\a', 'g', '\x2', '\x2', '\x204', '\x205', + '\a', 't', '\x2', '\x2', '\x205', '\x206', '\a', 'h', '\x2', '\x2', '\x206', + '\x207', '\a', '\x63', '\x2', '\x2', '\x207', '\x208', '\a', '\x65', '\x2', + '\x2', '\x208', '\x209', '\a', 'g', '\x2', '\x2', '\x209', '<', '\x3', + '\x2', '\x2', '\x2', '\x20A', '\x20B', '\a', 'n', '\x2', '\x2', '\x20B', + '\x20C', '\a', 'q', '\x2', '\x2', '\x20C', '\x20D', '\a', 'p', '\x2', + '\x2', '\x20D', '\x20E', '\a', 'i', '\x2', '\x2', '\x20E', '>', '\x3', + '\x2', '\x2', '\x2', '\x20F', '\x210', '\a', 'o', '\x2', '\x2', '\x210', + '\x211', '\a', 'q', '\x2', '\x2', '\x211', '\x212', '\a', '\x66', '\x2', + '\x2', '\x212', '\x213', '\a', 'w', '\x2', '\x2', '\x213', '\x214', '\a', + 'n', '\x2', '\x2', '\x214', '\x215', '\a', 'g', '\x2', '\x2', '\x215', + '@', '\x3', '\x2', '\x2', '\x2', '\x216', '\x217', '\a', 'p', '\x2', '\x2', + '\x217', '\x218', '\a', '\x63', '\x2', '\x2', '\x218', '\x219', '\a', + 'v', '\x2', '\x2', '\x219', '\x21A', '\a', 'k', '\x2', '\x2', '\x21A', + '\x21B', '\a', 'x', '\x2', '\x2', '\x21B', '\x21C', '\a', 'g', '\x2', + '\x2', '\x21C', '\x42', '\x3', '\x2', '\x2', '\x2', '\x21D', '\x21E', + '\a', 'p', '\x2', '\x2', '\x21E', '\x21F', '\a', 'g', '\x2', '\x2', '\x21F', + '\x220', '\a', 'y', '\x2', '\x2', '\x220', '\x44', '\x3', '\x2', '\x2', + '\x2', '\x221', '\x222', '\a', 'q', '\x2', '\x2', '\x222', '\x223', '\a', + 'r', '\x2', '\x2', '\x223', '\x224', '\a', 'g', '\x2', '\x2', '\x224', + '\x225', '\a', 'p', '\x2', '\x2', '\x225', '\x46', '\x3', '\x2', '\x2', + '\x2', '\x226', '\x227', '\a', 'q', '\x2', '\x2', '\x227', '\x228', '\a', + 'r', '\x2', '\x2', '\x228', '\x229', '\a', 'g', '\x2', '\x2', '\x229', + '\x22A', '\a', 'p', '\x2', '\x2', '\x22A', '\x22B', '\a', 'u', '\x2', + '\x2', '\x22B', 'H', '\x3', '\x2', '\x2', '\x2', '\x22C', '\x22D', '\a', + 'r', '\x2', '\x2', '\x22D', '\x22E', '\a', '\x63', '\x2', '\x2', '\x22E', + '\x22F', '\a', '\x65', '\x2', '\x2', '\x22F', '\x230', '\a', 'm', '\x2', + '\x2', '\x230', '\x231', '\a', '\x63', '\x2', '\x2', '\x231', '\x232', + '\a', 'i', '\x2', '\x2', '\x232', '\x233', '\a', 'g', '\x2', '\x2', '\x233', + 'J', '\x3', '\x2', '\x2', '\x2', '\x234', '\x235', '\a', 'r', '\x2', '\x2', + '\x235', '\x236', '\a', 't', '\x2', '\x2', '\x236', '\x237', '\a', 'k', + '\x2', '\x2', '\x237', '\x238', '\a', 'x', '\x2', '\x2', '\x238', '\x239', + '\a', '\x63', '\x2', '\x2', '\x239', '\x23A', '\a', 'v', '\x2', '\x2', + '\x23A', '\x23B', '\a', 'g', '\x2', '\x2', '\x23B', 'L', '\x3', '\x2', + '\x2', '\x2', '\x23C', '\x23D', '\a', 'r', '\x2', '\x2', '\x23D', '\x23E', + '\a', 't', '\x2', '\x2', '\x23E', '\x23F', '\a', 'q', '\x2', '\x2', '\x23F', + '\x240', '\a', 'v', '\x2', '\x2', '\x240', '\x241', '\a', 'g', '\x2', + '\x2', '\x241', '\x242', '\a', '\x65', '\x2', '\x2', '\x242', '\x243', + '\a', 'v', '\x2', '\x2', '\x243', '\x244', '\a', 'g', '\x2', '\x2', '\x244', + '\x245', '\a', '\x66', '\x2', '\x2', '\x245', 'N', '\x3', '\x2', '\x2', + '\x2', '\x246', '\x247', '\a', 'r', '\x2', '\x2', '\x247', '\x248', '\a', + 't', '\x2', '\x2', '\x248', '\x249', '\a', 'q', '\x2', '\x2', '\x249', + '\x24A', '\a', 'x', '\x2', '\x2', '\x24A', '\x24B', '\a', 'k', '\x2', + '\x2', '\x24B', '\x24C', '\a', '\x66', '\x2', '\x2', '\x24C', '\x24D', + '\a', 'g', '\x2', '\x2', '\x24D', '\x24E', '\a', 'u', '\x2', '\x2', '\x24E', + 'P', '\x3', '\x2', '\x2', '\x2', '\x24F', '\x250', '\a', 'r', '\x2', '\x2', + '\x250', '\x251', '\a', 'w', '\x2', '\x2', '\x251', '\x252', '\a', '\x64', + '\x2', '\x2', '\x252', '\x253', '\a', 'n', '\x2', '\x2', '\x253', '\x254', + '\a', 'k', '\x2', '\x2', '\x254', '\x255', '\a', '\x65', '\x2', '\x2', + '\x255', 'R', '\x3', '\x2', '\x2', '\x2', '\x256', '\x257', '\a', 't', + '\x2', '\x2', '\x257', '\x258', '\a', 'g', '\x2', '\x2', '\x258', '\x259', + '\a', 's', '\x2', '\x2', '\x259', '\x25A', '\a', 'w', '\x2', '\x2', '\x25A', + '\x25B', '\a', 'k', '\x2', '\x2', '\x25B', '\x25C', '\a', 't', '\x2', + '\x2', '\x25C', '\x25D', '\a', 'g', '\x2', '\x2', '\x25D', '\x25E', '\a', + 'u', '\x2', '\x2', '\x25E', 'T', '\x3', '\x2', '\x2', '\x2', '\x25F', + '\x260', '\a', 't', '\x2', '\x2', '\x260', '\x261', '\a', 'g', '\x2', + '\x2', '\x261', '\x262', '\a', 'v', '\x2', '\x2', '\x262', '\x263', '\a', + 'w', '\x2', '\x2', '\x263', '\x264', '\a', 't', '\x2', '\x2', '\x264', + '\x265', '\a', 'p', '\x2', '\x2', '\x265', 'V', '\x3', '\x2', '\x2', '\x2', + '\x266', '\x267', '\a', 'u', '\x2', '\x2', '\x267', '\x268', '\a', 'j', + '\x2', '\x2', '\x268', '\x269', '\a', 'q', '\x2', '\x2', '\x269', '\x26A', + '\a', 't', '\x2', '\x2', '\x26A', '\x26B', '\a', 'v', '\x2', '\x2', '\x26B', + 'X', '\x3', '\x2', '\x2', '\x2', '\x26C', '\x26D', '\a', 'u', '\x2', '\x2', + '\x26D', '\x26E', '\a', 'v', '\x2', '\x2', '\x26E', '\x26F', '\a', '\x63', + '\x2', '\x2', '\x26F', '\x270', '\a', 'v', '\x2', '\x2', '\x270', '\x271', + '\a', 'k', '\x2', '\x2', '\x271', '\x272', '\a', '\x65', '\x2', '\x2', + '\x272', 'Z', '\x3', '\x2', '\x2', '\x2', '\x273', '\x274', '\a', 'u', + '\x2', '\x2', '\x274', '\x275', '\a', 'v', '\x2', '\x2', '\x275', '\x276', + '\a', 't', '\x2', '\x2', '\x276', '\x277', '\a', 'k', '\x2', '\x2', '\x277', + '\x278', '\a', '\x65', '\x2', '\x2', '\x278', '\x279', '\a', 'v', '\x2', + '\x2', '\x279', '\x27A', '\a', 'h', '\x2', '\x2', '\x27A', '\x27B', '\a', + 'r', '\x2', '\x2', '\x27B', '\\', '\x3', '\x2', '\x2', '\x2', '\x27C', + '\x27D', '\a', 'u', '\x2', '\x2', '\x27D', '\x27E', '\a', 'w', '\x2', + '\x2', '\x27E', '\x27F', '\a', 'r', '\x2', '\x2', '\x27F', '\x280', '\a', + 'g', '\x2', '\x2', '\x280', '\x281', '\a', 't', '\x2', '\x2', '\x281', + '^', '\x3', '\x2', '\x2', '\x2', '\x282', '\x283', '\a', 'u', '\x2', '\x2', + '\x283', '\x284', '\a', 'y', '\x2', '\x2', '\x284', '\x285', '\a', 'k', + '\x2', '\x2', '\x285', '\x286', '\a', 'v', '\x2', '\x2', '\x286', '\x287', + '\a', '\x65', '\x2', '\x2', '\x287', '\x288', '\a', 'j', '\x2', '\x2', + '\x288', '`', '\x3', '\x2', '\x2', '\x2', '\x289', '\x28A', '\a', 'u', + '\x2', '\x2', '\x28A', '\x28B', '\a', '{', '\x2', '\x2', '\x28B', '\x28C', + '\a', 'p', '\x2', '\x2', '\x28C', '\x28D', '\a', '\x65', '\x2', '\x2', + '\x28D', '\x28E', '\a', 'j', '\x2', '\x2', '\x28E', '\x28F', '\a', 't', + '\x2', '\x2', '\x28F', '\x290', '\a', 'q', '\x2', '\x2', '\x290', '\x291', + '\a', 'p', '\x2', '\x2', '\x291', '\x292', '\a', 'k', '\x2', '\x2', '\x292', + '\x293', '\a', '|', '\x2', '\x2', '\x293', '\x294', '\a', 'g', '\x2', + '\x2', '\x294', '\x295', '\a', '\x66', '\x2', '\x2', '\x295', '\x62', + '\x3', '\x2', '\x2', '\x2', '\x296', '\x297', '\a', 'v', '\x2', '\x2', + '\x297', '\x298', '\a', 'j', '\x2', '\x2', '\x298', '\x299', '\a', 'k', + '\x2', '\x2', '\x299', '\x29A', '\a', 'u', '\x2', '\x2', '\x29A', '\x64', + '\x3', '\x2', '\x2', '\x2', '\x29B', '\x29C', '\a', 'v', '\x2', '\x2', + '\x29C', '\x29D', '\a', 'j', '\x2', '\x2', '\x29D', '\x29E', '\a', 't', + '\x2', '\x2', '\x29E', '\x29F', '\a', 'q', '\x2', '\x2', '\x29F', '\x2A0', + '\a', 'y', '\x2', '\x2', '\x2A0', '\x66', '\x3', '\x2', '\x2', '\x2', + '\x2A1', '\x2A2', '\a', 'v', '\x2', '\x2', '\x2A2', '\x2A3', '\a', 'j', + '\x2', '\x2', '\x2A3', '\x2A4', '\a', 't', '\x2', '\x2', '\x2A4', '\x2A5', + '\a', 'q', '\x2', '\x2', '\x2A5', '\x2A6', '\a', 'y', '\x2', '\x2', '\x2A6', + '\x2A7', '\a', 'u', '\x2', '\x2', '\x2A7', 'h', '\x3', '\x2', '\x2', '\x2', + '\x2A8', '\x2A9', '\a', 'v', '\x2', '\x2', '\x2A9', '\x2AA', '\a', 'q', + '\x2', '\x2', '\x2AA', 'j', '\x3', '\x2', '\x2', '\x2', '\x2AB', '\x2AC', + '\a', 'v', '\x2', '\x2', '\x2AC', '\x2AD', '\a', 't', '\x2', '\x2', '\x2AD', + '\x2AE', '\a', '\x63', '\x2', '\x2', '\x2AE', '\x2AF', '\a', 'p', '\x2', + '\x2', '\x2AF', '\x2B0', '\a', 'u', '\x2', '\x2', '\x2B0', '\x2B1', '\a', + 'k', '\x2', '\x2', '\x2B1', '\x2B2', '\a', 'g', '\x2', '\x2', '\x2B2', + '\x2B3', '\a', 'p', '\x2', '\x2', '\x2B3', '\x2B4', '\a', 'v', '\x2', + '\x2', '\x2B4', 'l', '\x3', '\x2', '\x2', '\x2', '\x2B5', '\x2B6', '\a', + 'v', '\x2', '\x2', '\x2B6', '\x2B7', '\a', 't', '\x2', '\x2', '\x2B7', + '\x2B8', '\a', '\x63', '\x2', '\x2', '\x2B8', '\x2B9', '\a', 'p', '\x2', + '\x2', '\x2B9', '\x2BA', '\a', 'u', '\x2', '\x2', '\x2BA', '\x2BB', '\a', + 'k', '\x2', '\x2', '\x2BB', '\x2BC', '\a', 'v', '\x2', '\x2', '\x2BC', + '\x2BD', '\a', 'k', '\x2', '\x2', '\x2BD', '\x2BE', '\a', 'x', '\x2', + '\x2', '\x2BE', '\x2BF', '\a', 'g', '\x2', '\x2', '\x2BF', 'n', '\x3', + '\x2', '\x2', '\x2', '\x2C0', '\x2C1', '\a', 'v', '\x2', '\x2', '\x2C1', + '\x2C2', '\a', 't', '\x2', '\x2', '\x2C2', '\x2C3', '\a', '{', '\x2', + '\x2', '\x2C3', 'p', '\x3', '\x2', '\x2', '\x2', '\x2C4', '\x2C5', '\a', + 'w', '\x2', '\x2', '\x2C5', '\x2C6', '\a', 'u', '\x2', '\x2', '\x2C6', + '\x2C7', '\a', 'g', '\x2', '\x2', '\x2C7', '\x2C8', '\a', 'u', '\x2', + '\x2', '\x2C8', 'r', '\x3', '\x2', '\x2', '\x2', '\x2C9', '\x2CA', '\a', + 'x', '\x2', '\x2', '\x2CA', '\x2CB', '\a', 'q', '\x2', '\x2', '\x2CB', + '\x2CC', '\a', 'k', '\x2', '\x2', '\x2CC', '\x2CD', '\a', '\x66', '\x2', + '\x2', '\x2CD', 't', '\x3', '\x2', '\x2', '\x2', '\x2CE', '\x2CF', '\a', + 'x', '\x2', '\x2', '\x2CF', '\x2D0', '\a', 'q', '\x2', '\x2', '\x2D0', + '\x2D1', '\a', 'n', '\x2', '\x2', '\x2D1', '\x2D2', '\a', '\x63', '\x2', + '\x2', '\x2D2', '\x2D3', '\a', 'v', '\x2', '\x2', '\x2D3', '\x2D4', '\a', + 'k', '\x2', '\x2', '\x2D4', '\x2D5', '\a', 'n', '\x2', '\x2', '\x2D5', + '\x2D6', '\a', 'g', '\x2', '\x2', '\x2D6', 'v', '\x3', '\x2', '\x2', '\x2', + '\x2D7', '\x2D8', '\a', 'y', '\x2', '\x2', '\x2D8', '\x2D9', '\a', 'j', + '\x2', '\x2', '\x2D9', '\x2DA', '\a', 'k', '\x2', '\x2', '\x2DA', '\x2DB', + '\a', 'n', '\x2', '\x2', '\x2DB', '\x2DC', '\a', 'g', '\x2', '\x2', '\x2DC', + 'x', '\x3', '\x2', '\x2', '\x2', '\x2DD', '\x2DE', '\a', 'y', '\x2', '\x2', + '\x2DE', '\x2DF', '\a', 'k', '\x2', '\x2', '\x2DF', '\x2E0', '\a', 'v', + '\x2', '\x2', '\x2E0', '\x2E1', '\a', 'j', '\x2', '\x2', '\x2E1', 'z', + '\x3', '\x2', '\x2', '\x2', '\x2E2', '\x2E3', '\a', '\x61', '\x2', '\x2', + '\x2E3', '|', '\x3', '\x2', '\x2', '\x2', '\x2E4', '\x2E9', '\x5', '\x7F', + '@', '\x2', '\x2E5', '\x2E9', '\x5', '\x81', '\x41', '\x2', '\x2E6', '\x2E9', + '\x5', '\x83', '\x42', '\x2', '\x2E7', '\x2E9', '\x5', '\x85', '\x43', + '\x2', '\x2E8', '\x2E4', '\x3', '\x2', '\x2', '\x2', '\x2E8', '\x2E5', + '\x3', '\x2', '\x2', '\x2', '\x2E8', '\x2E6', '\x3', '\x2', '\x2', '\x2', + '\x2E8', '\x2E7', '\x3', '\x2', '\x2', '\x2', '\x2E9', '~', '\x3', '\x2', + '\x2', '\x2', '\x2EA', '\x2EC', '\x5', '\x89', '\x45', '\x2', '\x2EB', + '\x2ED', '\x5', '\x87', '\x44', '\x2', '\x2EC', '\x2EB', '\x3', '\x2', + '\x2', '\x2', '\x2EC', '\x2ED', '\x3', '\x2', '\x2', '\x2', '\x2ED', '\x80', + '\x3', '\x2', '\x2', '\x2', '\x2EE', '\x2F0', '\x5', '\x97', 'L', '\x2', + '\x2EF', '\x2F1', '\x5', '\x87', '\x44', '\x2', '\x2F0', '\x2EF', '\x3', + '\x2', '\x2', '\x2', '\x2F0', '\x2F1', '\x3', '\x2', '\x2', '\x2', '\x2F1', + '\x82', '\x3', '\x2', '\x2', '\x2', '\x2F2', '\x2F4', '\x5', '\xA1', 'Q', + '\x2', '\x2F3', '\x2F5', '\x5', '\x87', '\x44', '\x2', '\x2F4', '\x2F3', + '\x3', '\x2', '\x2', '\x2', '\x2F4', '\x2F5', '\x3', '\x2', '\x2', '\x2', + '\x2F5', '\x84', '\x3', '\x2', '\x2', '\x2', '\x2F6', '\x2F8', '\x5', + '\xAB', 'V', '\x2', '\x2F7', '\x2F9', '\x5', '\x87', '\x44', '\x2', '\x2F8', + '\x2F7', '\x3', '\x2', '\x2', '\x2', '\x2F8', '\x2F9', '\x3', '\x2', '\x2', + '\x2', '\x2F9', '\x86', '\x3', '\x2', '\x2', '\x2', '\x2FA', '\x2FB', + '\t', '\x2', '\x2', '\x2', '\x2FB', '\x88', '\x3', '\x2', '\x2', '\x2', + '\x2FC', '\x307', '\a', '\x32', '\x2', '\x2', '\x2FD', '\x304', '\x5', + '\x8F', 'H', '\x2', '\x2FE', '\x300', '\x5', '\x8B', '\x46', '\x2', '\x2FF', + '\x2FE', '\x3', '\x2', '\x2', '\x2', '\x2FF', '\x300', '\x3', '\x2', '\x2', + '\x2', '\x300', '\x305', '\x3', '\x2', '\x2', '\x2', '\x301', '\x302', + '\x5', '\x95', 'K', '\x2', '\x302', '\x303', '\x5', '\x8B', '\x46', '\x2', + '\x303', '\x305', '\x3', '\x2', '\x2', '\x2', '\x304', '\x2FF', '\x3', + '\x2', '\x2', '\x2', '\x304', '\x301', '\x3', '\x2', '\x2', '\x2', '\x305', + '\x307', '\x3', '\x2', '\x2', '\x2', '\x306', '\x2FC', '\x3', '\x2', '\x2', + '\x2', '\x306', '\x2FD', '\x3', '\x2', '\x2', '\x2', '\x307', '\x8A', + '\x3', '\x2', '\x2', '\x2', '\x308', '\x30D', '\x5', '\x8D', 'G', '\x2', + '\x309', '\x30B', '\x5', '\x91', 'I', '\x2', '\x30A', '\x309', '\x3', + '\x2', '\x2', '\x2', '\x30A', '\x30B', '\x3', '\x2', '\x2', '\x2', '\x30B', + '\x30C', '\x3', '\x2', '\x2', '\x2', '\x30C', '\x30E', '\x5', '\x8D', + 'G', '\x2', '\x30D', '\x30A', '\x3', '\x2', '\x2', '\x2', '\x30D', '\x30E', + '\x3', '\x2', '\x2', '\x2', '\x30E', '\x8C', '\x3', '\x2', '\x2', '\x2', + '\x30F', '\x312', '\a', '\x32', '\x2', '\x2', '\x310', '\x312', '\x5', + '\x8F', 'H', '\x2', '\x311', '\x30F', '\x3', '\x2', '\x2', '\x2', '\x311', + '\x310', '\x3', '\x2', '\x2', '\x2', '\x312', '\x8E', '\x3', '\x2', '\x2', + '\x2', '\x313', '\x314', '\t', '\x3', '\x2', '\x2', '\x314', '\x90', '\x3', + '\x2', '\x2', '\x2', '\x315', '\x317', '\x5', '\x93', 'J', '\x2', '\x316', + '\x315', '\x3', '\x2', '\x2', '\x2', '\x317', '\x318', '\x3', '\x2', '\x2', + '\x2', '\x318', '\x316', '\x3', '\x2', '\x2', '\x2', '\x318', '\x319', + '\x3', '\x2', '\x2', '\x2', '\x319', '\x92', '\x3', '\x2', '\x2', '\x2', + '\x31A', '\x31D', '\x5', '\x8D', 'G', '\x2', '\x31B', '\x31D', '\a', '\x61', + '\x2', '\x2', '\x31C', '\x31A', '\x3', '\x2', '\x2', '\x2', '\x31C', '\x31B', + '\x3', '\x2', '\x2', '\x2', '\x31D', '\x94', '\x3', '\x2', '\x2', '\x2', + '\x31E', '\x320', '\a', '\x61', '\x2', '\x2', '\x31F', '\x31E', '\x3', + '\x2', '\x2', '\x2', '\x320', '\x321', '\x3', '\x2', '\x2', '\x2', '\x321', + '\x31F', '\x3', '\x2', '\x2', '\x2', '\x321', '\x322', '\x3', '\x2', '\x2', + '\x2', '\x322', '\x96', '\x3', '\x2', '\x2', '\x2', '\x323', '\x324', + '\a', '\x32', '\x2', '\x2', '\x324', '\x325', '\t', '\x4', '\x2', '\x2', + '\x325', '\x326', '\x5', '\x99', 'M', '\x2', '\x326', '\x98', '\x3', '\x2', + '\x2', '\x2', '\x327', '\x32C', '\x5', '\x9B', 'N', '\x2', '\x328', '\x32A', + '\x5', '\x9D', 'O', '\x2', '\x329', '\x328', '\x3', '\x2', '\x2', '\x2', + '\x329', '\x32A', '\x3', '\x2', '\x2', '\x2', '\x32A', '\x32B', '\x3', + '\x2', '\x2', '\x2', '\x32B', '\x32D', '\x5', '\x9B', 'N', '\x2', '\x32C', + '\x329', '\x3', '\x2', '\x2', '\x2', '\x32C', '\x32D', '\x3', '\x2', '\x2', + '\x2', '\x32D', '\x9A', '\x3', '\x2', '\x2', '\x2', '\x32E', '\x32F', + '\t', '\x5', '\x2', '\x2', '\x32F', '\x9C', '\x3', '\x2', '\x2', '\x2', + '\x330', '\x332', '\x5', '\x9F', 'P', '\x2', '\x331', '\x330', '\x3', + '\x2', '\x2', '\x2', '\x332', '\x333', '\x3', '\x2', '\x2', '\x2', '\x333', + '\x331', '\x3', '\x2', '\x2', '\x2', '\x333', '\x334', '\x3', '\x2', '\x2', + '\x2', '\x334', '\x9E', '\x3', '\x2', '\x2', '\x2', '\x335', '\x338', + '\x5', '\x9B', 'N', '\x2', '\x336', '\x338', '\a', '\x61', '\x2', '\x2', + '\x337', '\x335', '\x3', '\x2', '\x2', '\x2', '\x337', '\x336', '\x3', + '\x2', '\x2', '\x2', '\x338', '\xA0', '\x3', '\x2', '\x2', '\x2', '\x339', + '\x33B', '\a', '\x32', '\x2', '\x2', '\x33A', '\x33C', '\x5', '\x95', + 'K', '\x2', '\x33B', '\x33A', '\x3', '\x2', '\x2', '\x2', '\x33B', '\x33C', + '\x3', '\x2', '\x2', '\x2', '\x33C', '\x33D', '\x3', '\x2', '\x2', '\x2', + '\x33D', '\x33E', '\x5', '\xA3', 'R', '\x2', '\x33E', '\xA2', '\x3', '\x2', + '\x2', '\x2', '\x33F', '\x344', '\x5', '\xA5', 'S', '\x2', '\x340', '\x342', + '\x5', '\xA7', 'T', '\x2', '\x341', '\x340', '\x3', '\x2', '\x2', '\x2', + '\x341', '\x342', '\x3', '\x2', '\x2', '\x2', '\x342', '\x343', '\x3', + '\x2', '\x2', '\x2', '\x343', '\x345', '\x5', '\xA5', 'S', '\x2', '\x344', + '\x341', '\x3', '\x2', '\x2', '\x2', '\x344', '\x345', '\x3', '\x2', '\x2', + '\x2', '\x345', '\xA4', '\x3', '\x2', '\x2', '\x2', '\x346', '\x347', + '\t', '\x6', '\x2', '\x2', '\x347', '\xA6', '\x3', '\x2', '\x2', '\x2', + '\x348', '\x34A', '\x5', '\xA9', 'U', '\x2', '\x349', '\x348', '\x3', + '\x2', '\x2', '\x2', '\x34A', '\x34B', '\x3', '\x2', '\x2', '\x2', '\x34B', + '\x349', '\x3', '\x2', '\x2', '\x2', '\x34B', '\x34C', '\x3', '\x2', '\x2', + '\x2', '\x34C', '\xA8', '\x3', '\x2', '\x2', '\x2', '\x34D', '\x350', + '\x5', '\xA5', 'S', '\x2', '\x34E', '\x350', '\a', '\x61', '\x2', '\x2', + '\x34F', '\x34D', '\x3', '\x2', '\x2', '\x2', '\x34F', '\x34E', '\x3', + '\x2', '\x2', '\x2', '\x350', '\xAA', '\x3', '\x2', '\x2', '\x2', '\x351', + '\x352', '\a', '\x32', '\x2', '\x2', '\x352', '\x353', '\t', '\a', '\x2', + '\x2', '\x353', '\x354', '\x5', '\xAD', 'W', '\x2', '\x354', '\xAC', '\x3', + '\x2', '\x2', '\x2', '\x355', '\x35A', '\x5', '\xAF', 'X', '\x2', '\x356', + '\x358', '\x5', '\xB1', 'Y', '\x2', '\x357', '\x356', '\x3', '\x2', '\x2', + '\x2', '\x357', '\x358', '\x3', '\x2', '\x2', '\x2', '\x358', '\x359', + '\x3', '\x2', '\x2', '\x2', '\x359', '\x35B', '\x5', '\xAF', 'X', '\x2', + '\x35A', '\x357', '\x3', '\x2', '\x2', '\x2', '\x35A', '\x35B', '\x3', + '\x2', '\x2', '\x2', '\x35B', '\xAE', '\x3', '\x2', '\x2', '\x2', '\x35C', + '\x35D', '\t', '\b', '\x2', '\x2', '\x35D', '\xB0', '\x3', '\x2', '\x2', + '\x2', '\x35E', '\x360', '\x5', '\xB3', 'Z', '\x2', '\x35F', '\x35E', + '\x3', '\x2', '\x2', '\x2', '\x360', '\x361', '\x3', '\x2', '\x2', '\x2', + '\x361', '\x35F', '\x3', '\x2', '\x2', '\x2', '\x361', '\x362', '\x3', + '\x2', '\x2', '\x2', '\x362', '\xB2', '\x3', '\x2', '\x2', '\x2', '\x363', + '\x366', '\x5', '\xAF', 'X', '\x2', '\x364', '\x366', '\a', '\x61', '\x2', + '\x2', '\x365', '\x363', '\x3', '\x2', '\x2', '\x2', '\x365', '\x364', + '\x3', '\x2', '\x2', '\x2', '\x366', '\xB4', '\x3', '\x2', '\x2', '\x2', + '\x367', '\x36A', '\x5', '\xB7', '\\', '\x2', '\x368', '\x36A', '\x5', + '\xC3', '\x62', '\x2', '\x369', '\x367', '\x3', '\x2', '\x2', '\x2', '\x369', + '\x368', '\x3', '\x2', '\x2', '\x2', '\x36A', '\xB6', '\x3', '\x2', '\x2', + '\x2', '\x36B', '\x36C', '\x5', '\x8B', '\x46', '\x2', '\x36C', '\x36E', + '\a', '\x30', '\x2', '\x2', '\x36D', '\x36F', '\x5', '\x8B', '\x46', '\x2', + '\x36E', '\x36D', '\x3', '\x2', '\x2', '\x2', '\x36E', '\x36F', '\x3', + '\x2', '\x2', '\x2', '\x36F', '\x371', '\x3', '\x2', '\x2', '\x2', '\x370', + '\x372', '\x5', '\xB9', ']', '\x2', '\x371', '\x370', '\x3', '\x2', '\x2', + '\x2', '\x371', '\x372', '\x3', '\x2', '\x2', '\x2', '\x372', '\x374', + '\x3', '\x2', '\x2', '\x2', '\x373', '\x375', '\x5', '\xC1', '\x61', '\x2', + '\x374', '\x373', '\x3', '\x2', '\x2', '\x2', '\x374', '\x375', '\x3', + '\x2', '\x2', '\x2', '\x375', '\x387', '\x3', '\x2', '\x2', '\x2', '\x376', + '\x377', '\a', '\x30', '\x2', '\x2', '\x377', '\x379', '\x5', '\x8B', + '\x46', '\x2', '\x378', '\x37A', '\x5', '\xB9', ']', '\x2', '\x379', '\x378', + '\x3', '\x2', '\x2', '\x2', '\x379', '\x37A', '\x3', '\x2', '\x2', '\x2', + '\x37A', '\x37C', '\x3', '\x2', '\x2', '\x2', '\x37B', '\x37D', '\x5', + '\xC1', '\x61', '\x2', '\x37C', '\x37B', '\x3', '\x2', '\x2', '\x2', '\x37C', + '\x37D', '\x3', '\x2', '\x2', '\x2', '\x37D', '\x387', '\x3', '\x2', '\x2', + '\x2', '\x37E', '\x37F', '\x5', '\x8B', '\x46', '\x2', '\x37F', '\x381', + '\x5', '\xB9', ']', '\x2', '\x380', '\x382', '\x5', '\xC1', '\x61', '\x2', + '\x381', '\x380', '\x3', '\x2', '\x2', '\x2', '\x381', '\x382', '\x3', + '\x2', '\x2', '\x2', '\x382', '\x387', '\x3', '\x2', '\x2', '\x2', '\x383', + '\x384', '\x5', '\x8B', '\x46', '\x2', '\x384', '\x385', '\x5', '\xC1', + '\x61', '\x2', '\x385', '\x387', '\x3', '\x2', '\x2', '\x2', '\x386', + '\x36B', '\x3', '\x2', '\x2', '\x2', '\x386', '\x376', '\x3', '\x2', '\x2', + '\x2', '\x386', '\x37E', '\x3', '\x2', '\x2', '\x2', '\x386', '\x383', + '\x3', '\x2', '\x2', '\x2', '\x387', '\xB8', '\x3', '\x2', '\x2', '\x2', + '\x388', '\x389', '\x5', '\xBB', '^', '\x2', '\x389', '\x38A', '\x5', + '\xBD', '_', '\x2', '\x38A', '\xBA', '\x3', '\x2', '\x2', '\x2', '\x38B', + '\x38C', '\t', '\t', '\x2', '\x2', '\x38C', '\xBC', '\x3', '\x2', '\x2', + '\x2', '\x38D', '\x38F', '\x5', '\xBF', '`', '\x2', '\x38E', '\x38D', + '\x3', '\x2', '\x2', '\x2', '\x38E', '\x38F', '\x3', '\x2', '\x2', '\x2', + '\x38F', '\x390', '\x3', '\x2', '\x2', '\x2', '\x390', '\x391', '\x5', + '\x8B', '\x46', '\x2', '\x391', '\xBE', '\x3', '\x2', '\x2', '\x2', '\x392', + '\x393', '\t', '\n', '\x2', '\x2', '\x393', '\xC0', '\x3', '\x2', '\x2', + '\x2', '\x394', '\x395', '\t', '\v', '\x2', '\x2', '\x395', '\xC2', '\x3', + '\x2', '\x2', '\x2', '\x396', '\x397', '\x5', '\xC5', '\x63', '\x2', '\x397', + '\x399', '\x5', '\xC7', '\x64', '\x2', '\x398', '\x39A', '\x5', '\xC1', + '\x61', '\x2', '\x399', '\x398', '\x3', '\x2', '\x2', '\x2', '\x399', + '\x39A', '\x3', '\x2', '\x2', '\x2', '\x39A', '\xC4', '\x3', '\x2', '\x2', + '\x2', '\x39B', '\x39D', '\x5', '\x97', 'L', '\x2', '\x39C', '\x39E', + '\a', '\x30', '\x2', '\x2', '\x39D', '\x39C', '\x3', '\x2', '\x2', '\x2', + '\x39D', '\x39E', '\x3', '\x2', '\x2', '\x2', '\x39E', '\x3A7', '\x3', + '\x2', '\x2', '\x2', '\x39F', '\x3A0', '\a', '\x32', '\x2', '\x2', '\x3A0', + '\x3A2', '\t', '\x4', '\x2', '\x2', '\x3A1', '\x3A3', '\x5', '\x99', 'M', + '\x2', '\x3A2', '\x3A1', '\x3', '\x2', '\x2', '\x2', '\x3A2', '\x3A3', + '\x3', '\x2', '\x2', '\x2', '\x3A3', '\x3A4', '\x3', '\x2', '\x2', '\x2', + '\x3A4', '\x3A5', '\a', '\x30', '\x2', '\x2', '\x3A5', '\x3A7', '\x5', + '\x99', 'M', '\x2', '\x3A6', '\x39B', '\x3', '\x2', '\x2', '\x2', '\x3A6', + '\x39F', '\x3', '\x2', '\x2', '\x2', '\x3A7', '\xC6', '\x3', '\x2', '\x2', + '\x2', '\x3A8', '\x3A9', '\x5', '\xC9', '\x65', '\x2', '\x3A9', '\x3AA', + '\x5', '\xBD', '_', '\x2', '\x3AA', '\xC8', '\x3', '\x2', '\x2', '\x2', + '\x3AB', '\x3AC', '\t', '\f', '\x2', '\x2', '\x3AC', '\xCA', '\x3', '\x2', + '\x2', '\x2', '\x3AD', '\x3AE', '\a', 'v', '\x2', '\x2', '\x3AE', '\x3AF', + '\a', 't', '\x2', '\x2', '\x3AF', '\x3B0', '\a', 'w', '\x2', '\x2', '\x3B0', + '\x3B7', '\a', 'g', '\x2', '\x2', '\x3B1', '\x3B2', '\a', 'h', '\x2', + '\x2', '\x3B2', '\x3B3', '\a', '\x63', '\x2', '\x2', '\x3B3', '\x3B4', + '\a', 'n', '\x2', '\x2', '\x3B4', '\x3B5', '\a', 'u', '\x2', '\x2', '\x3B5', + '\x3B7', '\a', 'g', '\x2', '\x2', '\x3B6', '\x3AD', '\x3', '\x2', '\x2', + '\x2', '\x3B6', '\x3B1', '\x3', '\x2', '\x2', '\x2', '\x3B7', '\xCC', + '\x3', '\x2', '\x2', '\x2', '\x3B8', '\x3B9', '\a', ')', '\x2', '\x2', + '\x3B9', '\x3BA', '\x5', '\xCF', 'h', '\x2', '\x3BA', '\x3BB', '\a', ')', + '\x2', '\x2', '\x3BB', '\x3C1', '\x3', '\x2', '\x2', '\x2', '\x3BC', '\x3BD', + '\a', ')', '\x2', '\x2', '\x3BD', '\x3BE', '\x5', '\xD7', 'l', '\x2', + '\x3BE', '\x3BF', '\a', ')', '\x2', '\x2', '\x3BF', '\x3C1', '\x3', '\x2', + '\x2', '\x2', '\x3C0', '\x3B8', '\x3', '\x2', '\x2', '\x2', '\x3C0', '\x3BC', + '\x3', '\x2', '\x2', '\x2', '\x3C1', '\xCE', '\x3', '\x2', '\x2', '\x2', + '\x3C2', '\x3C3', '\n', '\r', '\x2', '\x2', '\x3C3', '\xD0', '\x3', '\x2', + '\x2', '\x2', '\x3C4', '\x3C6', '\a', '$', '\x2', '\x2', '\x3C5', '\x3C7', + '\x5', '\xD3', 'j', '\x2', '\x3C6', '\x3C5', '\x3', '\x2', '\x2', '\x2', + '\x3C6', '\x3C7', '\x3', '\x2', '\x2', '\x2', '\x3C7', '\x3C8', '\x3', + '\x2', '\x2', '\x2', '\x3C8', '\x3C9', '\a', '$', '\x2', '\x2', '\x3C9', + '\xD2', '\x3', '\x2', '\x2', '\x2', '\x3CA', '\x3CC', '\x5', '\xD5', 'k', + '\x2', '\x3CB', '\x3CA', '\x3', '\x2', '\x2', '\x2', '\x3CC', '\x3CD', + '\x3', '\x2', '\x2', '\x2', '\x3CD', '\x3CB', '\x3', '\x2', '\x2', '\x2', + '\x3CD', '\x3CE', '\x3', '\x2', '\x2', '\x2', '\x3CE', '\xD4', '\x3', + '\x2', '\x2', '\x2', '\x3CF', '\x3D2', '\n', '\xE', '\x2', '\x2', '\x3D0', + '\x3D2', '\x5', '\xD7', 'l', '\x2', '\x3D1', '\x3CF', '\x3', '\x2', '\x2', + '\x2', '\x3D1', '\x3D0', '\x3', '\x2', '\x2', '\x2', '\x3D2', '\xD6', + '\x3', '\x2', '\x2', '\x2', '\x3D3', '\x3D4', '\a', '^', '\x2', '\x2', + '\x3D4', '\x3D8', '\t', '\xF', '\x2', '\x2', '\x3D5', '\x3D8', '\x5', + '\xD9', 'm', '\x2', '\x3D6', '\x3D8', '\x5', '\xDD', 'o', '\x2', '\x3D7', + '\x3D3', '\x3', '\x2', '\x2', '\x2', '\x3D7', '\x3D5', '\x3', '\x2', '\x2', + '\x2', '\x3D7', '\x3D6', '\x3', '\x2', '\x2', '\x2', '\x3D8', '\xD8', + '\x3', '\x2', '\x2', '\x2', '\x3D9', '\x3DA', '\a', '^', '\x2', '\x2', + '\x3DA', '\x3E5', '\x5', '\xA5', 'S', '\x2', '\x3DB', '\x3DC', '\a', '^', + '\x2', '\x2', '\x3DC', '\x3DD', '\x5', '\xA5', 'S', '\x2', '\x3DD', '\x3DE', + '\x5', '\xA5', 'S', '\x2', '\x3DE', '\x3E5', '\x3', '\x2', '\x2', '\x2', + '\x3DF', '\x3E0', '\a', '^', '\x2', '\x2', '\x3E0', '\x3E1', '\x5', '\xDB', + 'n', '\x2', '\x3E1', '\x3E2', '\x5', '\xA5', 'S', '\x2', '\x3E2', '\x3E3', + '\x5', '\xA5', 'S', '\x2', '\x3E3', '\x3E5', '\x3', '\x2', '\x2', '\x2', + '\x3E4', '\x3D9', '\x3', '\x2', '\x2', '\x2', '\x3E4', '\x3DB', '\x3', + '\x2', '\x2', '\x2', '\x3E4', '\x3DF', '\x3', '\x2', '\x2', '\x2', '\x3E5', + '\xDA', '\x3', '\x2', '\x2', '\x2', '\x3E6', '\x3E7', '\t', '\x10', '\x2', + '\x2', '\x3E7', '\xDC', '\x3', '\x2', '\x2', '\x2', '\x3E8', '\x3EA', + '\a', '^', '\x2', '\x2', '\x3E9', '\x3EB', '\a', 'w', '\x2', '\x2', '\x3EA', + '\x3E9', '\x3', '\x2', '\x2', '\x2', '\x3EB', '\x3EC', '\x3', '\x2', '\x2', + '\x2', '\x3EC', '\x3EA', '\x3', '\x2', '\x2', '\x2', '\x3EC', '\x3ED', + '\x3', '\x2', '\x2', '\x2', '\x3ED', '\x3EE', '\x3', '\x2', '\x2', '\x2', + '\x3EE', '\x3EF', '\x5', '\x9B', 'N', '\x2', '\x3EF', '\x3F0', '\x5', + '\x9B', 'N', '\x2', '\x3F0', '\x3F1', '\x5', '\x9B', 'N', '\x2', '\x3F1', + '\x3F2', '\x5', '\x9B', 'N', '\x2', '\x3F2', '\xDE', '\x3', '\x2', '\x2', + '\x2', '\x3F3', '\x3F4', '\a', 'p', '\x2', '\x2', '\x3F4', '\x3F5', '\a', + 'w', '\x2', '\x2', '\x3F5', '\x3F6', '\a', 'n', '\x2', '\x2', '\x3F6', + '\x3F7', '\a', 'n', '\x2', '\x2', '\x3F7', '\xE0', '\x3', '\x2', '\x2', + '\x2', '\x3F8', '\x3F9', '\a', '*', '\x2', '\x2', '\x3F9', '\xE2', '\x3', + '\x2', '\x2', '\x2', '\x3FA', '\x3FB', '\a', '+', '\x2', '\x2', '\x3FB', + '\xE4', '\x3', '\x2', '\x2', '\x2', '\x3FC', '\x3FD', '\a', '}', '\x2', + '\x2', '\x3FD', '\xE6', '\x3', '\x2', '\x2', '\x2', '\x3FE', '\x3FF', + '\a', '\x7F', '\x2', '\x2', '\x3FF', '\xE8', '\x3', '\x2', '\x2', '\x2', + '\x400', '\x401', '\a', ']', '\x2', '\x2', '\x401', '\xEA', '\x3', '\x2', + '\x2', '\x2', '\x402', '\x403', '\a', '_', '\x2', '\x2', '\x403', '\xEC', + '\x3', '\x2', '\x2', '\x2', '\x404', '\x405', '\a', '=', '\x2', '\x2', + '\x405', '\xEE', '\x3', '\x2', '\x2', '\x2', '\x406', '\x407', '\a', '.', + '\x2', '\x2', '\x407', '\xF0', '\x3', '\x2', '\x2', '\x2', '\x408', '\x409', + '\a', '\x30', '\x2', '\x2', '\x409', '\xF2', '\x3', '\x2', '\x2', '\x2', + '\x40A', '\x40B', '\a', '\x30', '\x2', '\x2', '\x40B', '\x40C', '\a', + '\x30', '\x2', '\x2', '\x40C', '\x40D', '\a', '\x30', '\x2', '\x2', '\x40D', + '\xF4', '\x3', '\x2', '\x2', '\x2', '\x40E', '\x40F', '\a', '\x42', '\x2', + '\x2', '\x40F', '\xF6', '\x3', '\x2', '\x2', '\x2', '\x410', '\x411', + '\a', '<', '\x2', '\x2', '\x411', '\x412', '\a', '<', '\x2', '\x2', '\x412', + '\xF8', '\x3', '\x2', '\x2', '\x2', '\x413', '\x414', '\a', '?', '\x2', + '\x2', '\x414', '\xFA', '\x3', '\x2', '\x2', '\x2', '\x415', '\x416', + '\a', '@', '\x2', '\x2', '\x416', '\xFC', '\x3', '\x2', '\x2', '\x2', + '\x417', '\x418', '\a', '>', '\x2', '\x2', '\x418', '\xFE', '\x3', '\x2', + '\x2', '\x2', '\x419', '\x41A', '\a', '#', '\x2', '\x2', '\x41A', '\x100', + '\x3', '\x2', '\x2', '\x2', '\x41B', '\x41C', '\a', '\x80', '\x2', '\x2', + '\x41C', '\x102', '\x3', '\x2', '\x2', '\x2', '\x41D', '\x41E', '\a', + '\x41', '\x2', '\x2', '\x41E', '\x104', '\x3', '\x2', '\x2', '\x2', '\x41F', + '\x420', '\a', '<', '\x2', '\x2', '\x420', '\x106', '\x3', '\x2', '\x2', + '\x2', '\x421', '\x422', '\a', '/', '\x2', '\x2', '\x422', '\x423', '\a', + '@', '\x2', '\x2', '\x423', '\x108', '\x3', '\x2', '\x2', '\x2', '\x424', + '\x425', '\a', '?', '\x2', '\x2', '\x425', '\x426', '\a', '?', '\x2', + '\x2', '\x426', '\x10A', '\x3', '\x2', '\x2', '\x2', '\x427', '\x428', + '\a', '>', '\x2', '\x2', '\x428', '\x429', '\a', '?', '\x2', '\x2', '\x429', + '\x10C', '\x3', '\x2', '\x2', '\x2', '\x42A', '\x42B', '\a', '@', '\x2', + '\x2', '\x42B', '\x42C', '\a', '?', '\x2', '\x2', '\x42C', '\x10E', '\x3', + '\x2', '\x2', '\x2', '\x42D', '\x42E', '\a', '#', '\x2', '\x2', '\x42E', + '\x42F', '\a', '?', '\x2', '\x2', '\x42F', '\x110', '\x3', '\x2', '\x2', + '\x2', '\x430', '\x431', '\a', '(', '\x2', '\x2', '\x431', '\x432', '\a', + '(', '\x2', '\x2', '\x432', '\x112', '\x3', '\x2', '\x2', '\x2', '\x433', + '\x434', '\a', '~', '\x2', '\x2', '\x434', '\x435', '\a', '~', '\x2', + '\x2', '\x435', '\x114', '\x3', '\x2', '\x2', '\x2', '\x436', '\x437', + '\a', '-', '\x2', '\x2', '\x437', '\x438', '\a', '-', '\x2', '\x2', '\x438', + '\x116', '\x3', '\x2', '\x2', '\x2', '\x439', '\x43A', '\a', '/', '\x2', + '\x2', '\x43A', '\x43B', '\a', '/', '\x2', '\x2', '\x43B', '\x118', '\x3', + '\x2', '\x2', '\x2', '\x43C', '\x43D', '\a', '-', '\x2', '\x2', '\x43D', + '\x11A', '\x3', '\x2', '\x2', '\x2', '\x43E', '\x43F', '\a', '/', '\x2', + '\x2', '\x43F', '\x11C', '\x3', '\x2', '\x2', '\x2', '\x440', '\x441', + '\a', ',', '\x2', '\x2', '\x441', '\x11E', '\x3', '\x2', '\x2', '\x2', + '\x442', '\x443', '\a', '\x31', '\x2', '\x2', '\x443', '\x120', '\x3', + '\x2', '\x2', '\x2', '\x444', '\x445', '\a', '(', '\x2', '\x2', '\x445', + '\x122', '\x3', '\x2', '\x2', '\x2', '\x446', '\x447', '\a', '~', '\x2', + '\x2', '\x447', '\x124', '\x3', '\x2', '\x2', '\x2', '\x448', '\x449', + '\a', '`', '\x2', '\x2', '\x449', '\x126', '\x3', '\x2', '\x2', '\x2', + '\x44A', '\x44B', '\a', '\'', '\x2', '\x2', '\x44B', '\x128', '\x3', '\x2', + '\x2', '\x2', '\x44C', '\x44D', '\a', '-', '\x2', '\x2', '\x44D', '\x44E', + '\a', '?', '\x2', '\x2', '\x44E', '\x12A', '\x3', '\x2', '\x2', '\x2', + '\x44F', '\x450', '\a', '/', '\x2', '\x2', '\x450', '\x451', '\a', '?', + '\x2', '\x2', '\x451', '\x12C', '\x3', '\x2', '\x2', '\x2', '\x452', '\x453', + '\a', ',', '\x2', '\x2', '\x453', '\x454', '\a', '?', '\x2', '\x2', '\x454', + '\x12E', '\x3', '\x2', '\x2', '\x2', '\x455', '\x456', '\a', '\x31', '\x2', + '\x2', '\x456', '\x457', '\a', '?', '\x2', '\x2', '\x457', '\x130', '\x3', + '\x2', '\x2', '\x2', '\x458', '\x459', '\a', '(', '\x2', '\x2', '\x459', + '\x45A', '\a', '?', '\x2', '\x2', '\x45A', '\x132', '\x3', '\x2', '\x2', + '\x2', '\x45B', '\x45C', '\a', '~', '\x2', '\x2', '\x45C', '\x45D', '\a', + '?', '\x2', '\x2', '\x45D', '\x134', '\x3', '\x2', '\x2', '\x2', '\x45E', + '\x45F', '\a', '`', '\x2', '\x2', '\x45F', '\x460', '\a', '?', '\x2', + '\x2', '\x460', '\x136', '\x3', '\x2', '\x2', '\x2', '\x461', '\x462', + '\a', '\'', '\x2', '\x2', '\x462', '\x463', '\a', '?', '\x2', '\x2', '\x463', + '\x138', '\x3', '\x2', '\x2', '\x2', '\x464', '\x465', '\a', '>', '\x2', + '\x2', '\x465', '\x466', '\a', '>', '\x2', '\x2', '\x466', '\x467', '\a', + '?', '\x2', '\x2', '\x467', '\x13A', '\x3', '\x2', '\x2', '\x2', '\x468', + '\x469', '\a', '@', '\x2', '\x2', '\x469', '\x46A', '\a', '@', '\x2', + '\x2', '\x46A', '\x46B', '\a', '?', '\x2', '\x2', '\x46B', '\x13C', '\x3', + '\x2', '\x2', '\x2', '\x46C', '\x46D', '\a', '@', '\x2', '\x2', '\x46D', + '\x46E', '\a', '@', '\x2', '\x2', '\x46E', '\x46F', '\a', '@', '\x2', + '\x2', '\x46F', '\x470', '\a', '?', '\x2', '\x2', '\x470', '\x13E', '\x3', + '\x2', '\x2', '\x2', '\x471', '\x475', '\x5', '\x141', '\xA1', '\x2', + '\x472', '\x474', '\x5', '\x143', '\xA2', '\x2', '\x473', '\x472', '\x3', + '\x2', '\x2', '\x2', '\x474', '\x477', '\x3', '\x2', '\x2', '\x2', '\x475', + '\x473', '\x3', '\x2', '\x2', '\x2', '\x475', '\x476', '\x3', '\x2', '\x2', + '\x2', '\x476', '\x140', '\x3', '\x2', '\x2', '\x2', '\x477', '\x475', + '\x3', '\x2', '\x2', '\x2', '\x478', '\x47F', '\t', '\x11', '\x2', '\x2', + '\x479', '\x47A', '\n', '\x12', '\x2', '\x2', '\x47A', '\x47F', '\x6', + '\xA1', '\x2', '\x2', '\x47B', '\x47C', '\t', '\x13', '\x2', '\x2', '\x47C', + '\x47D', '\t', '\x14', '\x2', '\x2', '\x47D', '\x47F', '\x6', '\xA1', + '\x3', '\x2', '\x47E', '\x478', '\x3', '\x2', '\x2', '\x2', '\x47E', '\x479', + '\x3', '\x2', '\x2', '\x2', '\x47E', '\x47B', '\x3', '\x2', '\x2', '\x2', + '\x47F', '\x142', '\x3', '\x2', '\x2', '\x2', '\x480', '\x487', '\t', + '\x15', '\x2', '\x2', '\x481', '\x482', '\n', '\x12', '\x2', '\x2', '\x482', + '\x487', '\x6', '\xA2', '\x4', '\x2', '\x483', '\x484', '\t', '\x13', + '\x2', '\x2', '\x484', '\x485', '\t', '\x14', '\x2', '\x2', '\x485', '\x487', + '\x6', '\xA2', '\x5', '\x2', '\x486', '\x480', '\x3', '\x2', '\x2', '\x2', + '\x486', '\x481', '\x3', '\x2', '\x2', '\x2', '\x486', '\x483', '\x3', + '\x2', '\x2', '\x2', '\x487', '\x144', '\x3', '\x2', '\x2', '\x2', '\x488', + '\x48A', '\t', '\x16', '\x2', '\x2', '\x489', '\x488', '\x3', '\x2', '\x2', + '\x2', '\x48A', '\x48B', '\x3', '\x2', '\x2', '\x2', '\x48B', '\x489', + '\x3', '\x2', '\x2', '\x2', '\x48B', '\x48C', '\x3', '\x2', '\x2', '\x2', + '\x48C', '\x48D', '\x3', '\x2', '\x2', '\x2', '\x48D', '\x48E', '\b', + '\xA3', '\x2', '\x2', '\x48E', '\x146', '\x3', '\x2', '\x2', '\x2', '\x48F', + '\x490', '\a', '\x31', '\x2', '\x2', '\x490', '\x491', '\a', ',', '\x2', + '\x2', '\x491', '\x495', '\x3', '\x2', '\x2', '\x2', '\x492', '\x494', + '\v', '\x2', '\x2', '\x2', '\x493', '\x492', '\x3', '\x2', '\x2', '\x2', + '\x494', '\x497', '\x3', '\x2', '\x2', '\x2', '\x495', '\x496', '\x3', + '\x2', '\x2', '\x2', '\x495', '\x493', '\x3', '\x2', '\x2', '\x2', '\x496', + '\x498', '\x3', '\x2', '\x2', '\x2', '\x497', '\x495', '\x3', '\x2', '\x2', + '\x2', '\x498', '\x499', '\a', ',', '\x2', '\x2', '\x499', '\x49A', '\a', + '\x31', '\x2', '\x2', '\x49A', '\x49B', '\x3', '\x2', '\x2', '\x2', '\x49B', + '\x49C', '\b', '\xA4', '\x2', '\x2', '\x49C', '\x148', '\x3', '\x2', '\x2', + '\x2', '\x49D', '\x49E', '\a', '\x31', '\x2', '\x2', '\x49E', '\x49F', + '\a', '\x31', '\x2', '\x2', '\x49F', '\x4A3', '\x3', '\x2', '\x2', '\x2', + '\x4A0', '\x4A2', '\n', '\x17', '\x2', '\x2', '\x4A1', '\x4A0', '\x3', + '\x2', '\x2', '\x2', '\x4A2', '\x4A5', '\x3', '\x2', '\x2', '\x2', '\x4A3', + '\x4A1', '\x3', '\x2', '\x2', '\x2', '\x4A3', '\x4A4', '\x3', '\x2', '\x2', + '\x2', '\x4A4', '\x4A6', '\x3', '\x2', '\x2', '\x2', '\x4A5', '\x4A3', + '\x3', '\x2', '\x2', '\x2', '\x4A6', '\x4A7', '\b', '\xA5', '\x2', '\x2', + '\x4A7', '\x14A', '\x3', '\x2', '\x2', '\x2', '\x39', '\x2', '\x2E8', + '\x2EC', '\x2F0', '\x2F4', '\x2F8', '\x2FF', '\x304', '\x306', '\x30A', + '\x30D', '\x311', '\x318', '\x31C', '\x321', '\x329', '\x32C', '\x333', + '\x337', '\x33B', '\x341', '\x344', '\x34B', '\x34F', '\x357', '\x35A', + '\x361', '\x365', '\x369', '\x36E', '\x371', '\x374', '\x379', '\x37C', + '\x381', '\x386', '\x38E', '\x399', '\x39D', '\x3A2', '\x3A6', '\x3B6', + '\x3C0', '\x3C6', '\x3CD', '\x3D1', '\x3D7', '\x3E4', '\x3EC', '\x475', + '\x47E', '\x486', '\x48B', '\x495', '\x4A3', '\x3', '\x2', '\x4', '\x2', + }; + + public static readonly ATN _ATN = + new ATNDeserializer().Deserialize(_serializedATN); + + +} diff --git a/Tests.Runtime.Standard/Java9/Java9Parser.cs b/Tests.Runtime.Standard/Java9/Java9Parser.cs new file mode 100644 index 0000000..504672a --- /dev/null +++ b/Tests.Runtime.Standard/Java9/Java9Parser.cs @@ -0,0 +1,22060 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// ANTLR Version: 4.7.2 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +// Generated from C:\Users\Spitz\source\repos\AntlrBug_40\AntlrConsole3\Java9Parser.g4 by ANTLR 4.7.2 + +// Unreachable code detected +#pragma warning disable 0162 +// The variable '...' is assigned but its value is never used +#pragma warning disable 0219 +// Missing XML comment for publicly visible type or member '...' +#pragma warning disable 1591 +// Ambiguous reference in cref attribute +#pragma warning disable 419 + +using System; +using System.IO; +using System.Text; +using System.Diagnostics; +using System.Collections.Generic; +using Antlr4.Runtime; +using Antlr4.Runtime.Atn; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; +using DFA = Antlr4.Runtime.Dfa.DFA; + +[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.7.2")] +[System.CLSCompliant(false)] +public partial class Java9Parser : Parser { + protected static DFA[] decisionToDFA; + protected static PredictionContextCache sharedContextCache = new PredictionContextCache(); + public const int + ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, + CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, + ENUM=16, EXPORTS=17, EXTENDS=18, FINAL=19, FINALLY=20, FLOAT=21, FOR=22, + IF=23, GOTO=24, IMPLEMENTS=25, IMPORT=26, INSTANCEOF=27, INT=28, INTERFACE=29, + LONG=30, MODULE=31, NATIVE=32, NEW=33, OPEN=34, OPENS=35, PACKAGE=36, + PRIVATE=37, PROTECTED=38, PROVIDES=39, PUBLIC=40, REQUIRES=41, RETURN=42, + SHORT=43, STATIC=44, STRICTFP=45, SUPER=46, SWITCH=47, SYNCHRONIZED=48, + THIS=49, THROW=50, THROWS=51, TO=52, TRANSIENT=53, TRANSITIVE=54, TRY=55, + USES=56, VOID=57, VOLATILE=58, WHILE=59, WITH=60, UNDER_SCORE=61, IntegerLiteral=62, + FloatingPointLiteral=63, BooleanLiteral=64, CharacterLiteral=65, StringLiteral=66, + NullLiteral=67, LPAREN=68, RPAREN=69, LBRACE=70, RBRACE=71, LBRACK=72, + RBRACK=73, SEMI=74, COMMA=75, DOT=76, ELLIPSIS=77, AT=78, COLONCOLON=79, + ASSIGN=80, GT=81, LT=82, BANG=83, TILDE=84, QUESTION=85, COLON=86, ARROW=87, + EQUAL=88, LE=89, GE=90, NOTEQUAL=91, AND=92, OR=93, INC=94, DEC=95, ADD=96, + SUB=97, MUL=98, DIV=99, BITAND=100, BITOR=101, CARET=102, MOD=103, ADD_ASSIGN=104, + SUB_ASSIGN=105, MUL_ASSIGN=106, DIV_ASSIGN=107, AND_ASSIGN=108, OR_ASSIGN=109, + XOR_ASSIGN=110, MOD_ASSIGN=111, LSHIFT_ASSIGN=112, RSHIFT_ASSIGN=113, + URSHIFT_ASSIGN=114, Identifier=115, WS=116, COMMENT=117, LINE_COMMENT=118; + public const int + RULE_literal = 0, RULE_primitiveType = 1, RULE_numericType = 2, RULE_integralType = 3, + RULE_floatingPointType = 4, RULE_referenceType = 5, RULE_classOrInterfaceType = 6, + RULE_classType = 7, RULE_classType_lf_classOrInterfaceType = 8, RULE_classType_lfno_classOrInterfaceType = 9, + RULE_interfaceType = 10, RULE_interfaceType_lf_classOrInterfaceType = 11, + RULE_interfaceType_lfno_classOrInterfaceType = 12, RULE_typeVariable = 13, + RULE_arrayType = 14, RULE_dims = 15, RULE_typeParameter = 16, RULE_typeParameterModifier = 17, + RULE_typeBound = 18, RULE_additionalBound = 19, RULE_typeArguments = 20, + RULE_typeArgumentList = 21, RULE_typeArgument = 22, RULE_wildcard = 23, + RULE_wildcardBounds = 24, RULE_moduleName = 25, RULE_packageName = 26, + RULE_typeName = 27, RULE_packageOrTypeName = 28, RULE_expressionName = 29, + RULE_methodName = 30, RULE_ambiguousName = 31, RULE_compilationUnit = 32, + RULE_ordinaryCompilation = 33, RULE_modularCompilation = 34, RULE_packageDeclaration = 35, + RULE_packageModifier = 36, RULE_importDeclaration = 37, RULE_singleTypeImportDeclaration = 38, + RULE_typeImportOnDemandDeclaration = 39, RULE_singleStaticImportDeclaration = 40, + RULE_staticImportOnDemandDeclaration = 41, RULE_typeDeclaration = 42, + RULE_moduleDeclaration = 43, RULE_moduleDirective = 44, RULE_requiresModifier = 45, + RULE_classDeclaration = 46, RULE_normalClassDeclaration = 47, RULE_classModifier = 48, + RULE_typeParameters = 49, RULE_typeParameterList = 50, RULE_superclass = 51, + RULE_superinterfaces = 52, RULE_interfaceTypeList = 53, RULE_classBody = 54, + RULE_classBodyDeclaration = 55, RULE_classMemberDeclaration = 56, RULE_fieldDeclaration = 57, + RULE_fieldModifier = 58, RULE_variableDeclaratorList = 59, RULE_variableDeclarator = 60, + RULE_variableDeclaratorId = 61, RULE_variableInitializer = 62, RULE_unannType = 63, + RULE_unannPrimitiveType = 64, RULE_unannReferenceType = 65, RULE_unannClassOrInterfaceType = 66, + RULE_unannClassType = 67, RULE_unannClassType_lf_unannClassOrInterfaceType = 68, + RULE_unannClassType_lfno_unannClassOrInterfaceType = 69, RULE_unannInterfaceType = 70, + RULE_unannInterfaceType_lf_unannClassOrInterfaceType = 71, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType = 72, + RULE_unannTypeVariable = 73, RULE_unannArrayType = 74, RULE_methodDeclaration = 75, + RULE_methodModifier = 76, RULE_methodHeader = 77, RULE_result = 78, RULE_methodDeclarator = 79, + RULE_formalParameterList = 80, RULE_formalParameters = 81, RULE_formalParameter = 82, + RULE_variableModifier = 83, RULE_lastFormalParameter = 84, RULE_receiverParameter = 85, + RULE_throws_ = 86, RULE_exceptionTypeList = 87, RULE_exceptionType = 88, + RULE_methodBody = 89, RULE_instanceInitializer = 90, RULE_staticInitializer = 91, + RULE_constructorDeclaration = 92, RULE_constructorModifier = 93, RULE_constructorDeclarator = 94, + RULE_simpleTypeName = 95, RULE_constructorBody = 96, RULE_explicitConstructorInvocation = 97, + RULE_enumDeclaration = 98, RULE_enumBody = 99, RULE_enumConstantList = 100, + RULE_enumConstant = 101, RULE_enumConstantModifier = 102, RULE_enumBodyDeclarations = 103, + RULE_interfaceDeclaration = 104, RULE_normalInterfaceDeclaration = 105, + RULE_interfaceModifier = 106, RULE_extendsInterfaces = 107, RULE_interfaceBody = 108, + RULE_interfaceMemberDeclaration = 109, RULE_constantDeclaration = 110, + RULE_constantModifier = 111, RULE_interfaceMethodDeclaration = 112, RULE_interfaceMethodModifier = 113, + RULE_annotationTypeDeclaration = 114, RULE_annotationTypeBody = 115, RULE_annotationTypeMemberDeclaration = 116, + RULE_annotationTypeElementDeclaration = 117, RULE_annotationTypeElementModifier = 118, + RULE_defaultValue = 119, RULE_annotation = 120, RULE_normalAnnotation = 121, + RULE_elementValuePairList = 122, RULE_elementValuePair = 123, RULE_elementValue = 124, + RULE_elementValueArrayInitializer = 125, RULE_elementValueList = 126, + RULE_markerAnnotation = 127, RULE_singleElementAnnotation = 128, RULE_arrayInitializer = 129, + RULE_variableInitializerList = 130, RULE_block = 131, RULE_blockStatements = 132, + RULE_blockStatement = 133, RULE_localVariableDeclarationStatement = 134, + RULE_localVariableDeclaration = 135, RULE_statement = 136, RULE_statementNoShortIf = 137, + RULE_statementWithoutTrailingSubstatement = 138, RULE_emptyStatement = 139, + RULE_labeledStatement = 140, RULE_labeledStatementNoShortIf = 141, RULE_expressionStatement = 142, + RULE_statementExpression = 143, RULE_ifThenStatement = 144, RULE_ifThenElseStatement = 145, + RULE_ifThenElseStatementNoShortIf = 146, RULE_assertStatement = 147, RULE_switchStatement = 148, + RULE_switchBlock = 149, RULE_switchBlockStatementGroup = 150, RULE_switchLabels = 151, + RULE_switchLabel = 152, RULE_enumConstantName = 153, RULE_whileStatement = 154, + RULE_whileStatementNoShortIf = 155, RULE_doStatement = 156, RULE_forStatement = 157, + RULE_forStatementNoShortIf = 158, RULE_basicForStatement = 159, RULE_basicForStatementNoShortIf = 160, + RULE_forInit = 161, RULE_forUpdate = 162, RULE_statementExpressionList = 163, + RULE_enhancedForStatement = 164, RULE_enhancedForStatementNoShortIf = 165, + RULE_breakStatement = 166, RULE_continueStatement = 167, RULE_returnStatement = 168, + RULE_throwStatement = 169, RULE_synchronizedStatement = 170, RULE_tryStatement = 171, + RULE_catches = 172, RULE_catchClause = 173, RULE_catchFormalParameter = 174, + RULE_catchType = 175, RULE_finally_ = 176, RULE_tryWithResourcesStatement = 177, + RULE_resourceSpecification = 178, RULE_resourceList = 179, RULE_resource = 180, + RULE_variableAccess = 181, RULE_primary = 182, RULE_primaryNoNewArray = 183, + RULE_primaryNoNewArray_lf_arrayAccess = 184, RULE_primaryNoNewArray_lfno_arrayAccess = 185, + RULE_primaryNoNewArray_lf_primary = 186, RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary = 187, + RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary = 188, RULE_primaryNoNewArray_lfno_primary = 189, + RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary = 190, + RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary = 191, + RULE_classLiteral = 192, RULE_classInstanceCreationExpression = 193, RULE_classInstanceCreationExpression_lf_primary = 194, + RULE_classInstanceCreationExpression_lfno_primary = 195, RULE_typeArgumentsOrDiamond = 196, + RULE_fieldAccess = 197, RULE_fieldAccess_lf_primary = 198, RULE_fieldAccess_lfno_primary = 199, + RULE_arrayAccess = 200, RULE_arrayAccess_lf_primary = 201, RULE_arrayAccess_lfno_primary = 202, + RULE_methodInvocation = 203, RULE_methodInvocation_lf_primary = 204, RULE_methodInvocation_lfno_primary = 205, + RULE_argumentList = 206, RULE_methodReference = 207, RULE_methodReference_lf_primary = 208, + RULE_methodReference_lfno_primary = 209, RULE_arrayCreationExpression = 210, + RULE_dimExprs = 211, RULE_dimExpr = 212, RULE_constantExpression = 213, + RULE_expression = 214, RULE_lambdaExpression = 215, RULE_lambdaParameters = 216, + RULE_inferredFormalParameterList = 217, RULE_lambdaBody = 218, RULE_assignmentExpression = 219, + RULE_assignment = 220, RULE_leftHandSide = 221, RULE_assignmentOperator = 222, + RULE_conditionalExpression = 223, RULE_conditionalOrExpression = 224, + RULE_conditionalAndExpression = 225, RULE_inclusiveOrExpression = 226, + RULE_exclusiveOrExpression = 227, RULE_andExpression = 228, RULE_equalityExpression = 229, + RULE_relationalExpression = 230, RULE_shiftExpression = 231, RULE_additiveExpression = 232, + RULE_multiplicativeExpression = 233, RULE_unaryExpression = 234, RULE_preIncrementExpression = 235, + RULE_preDecrementExpression = 236, RULE_unaryExpressionNotPlusMinus = 237, + RULE_postfixExpression = 238, RULE_postIncrementExpression = 239, RULE_postIncrementExpression_lf_postfixExpression = 240, + RULE_postDecrementExpression = 241, RULE_postDecrementExpression_lf_postfixExpression = 242, + RULE_castExpression = 243, RULE_identifier = 244; + public static readonly string[] ruleNames = { + "literal", "primitiveType", "numericType", "integralType", "floatingPointType", + "referenceType", "classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType", + "classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType", + "interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType", + "dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound", + "typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds", + "moduleName", "packageName", "typeName", "packageOrTypeName", "expressionName", + "methodName", "ambiguousName", "compilationUnit", "ordinaryCompilation", + "modularCompilation", "packageDeclaration", "packageModifier", "importDeclaration", + "singleTypeImportDeclaration", "typeImportOnDemandDeclaration", "singleStaticImportDeclaration", + "staticImportOnDemandDeclaration", "typeDeclaration", "moduleDeclaration", + "moduleDirective", "requiresModifier", "classDeclaration", "normalClassDeclaration", + "classModifier", "typeParameters", "typeParameterList", "superclass", + "superinterfaces", "interfaceTypeList", "classBody", "classBodyDeclaration", + "classMemberDeclaration", "fieldDeclaration", "fieldModifier", "variableDeclaratorList", + "variableDeclarator", "variableDeclaratorId", "variableInitializer", "unannType", + "unannPrimitiveType", "unannReferenceType", "unannClassOrInterfaceType", + "unannClassType", "unannClassType_lf_unannClassOrInterfaceType", "unannClassType_lfno_unannClassOrInterfaceType", + "unannInterfaceType", "unannInterfaceType_lf_unannClassOrInterfaceType", + "unannInterfaceType_lfno_unannClassOrInterfaceType", "unannTypeVariable", + "unannArrayType", "methodDeclaration", "methodModifier", "methodHeader", + "result", "methodDeclarator", "formalParameterList", "formalParameters", + "formalParameter", "variableModifier", "lastFormalParameter", "receiverParameter", + "throws_", "exceptionTypeList", "exceptionType", "methodBody", "instanceInitializer", + "staticInitializer", "constructorDeclaration", "constructorModifier", + "constructorDeclarator", "simpleTypeName", "constructorBody", "explicitConstructorInvocation", + "enumDeclaration", "enumBody", "enumConstantList", "enumConstant", "enumConstantModifier", + "enumBodyDeclarations", "interfaceDeclaration", "normalInterfaceDeclaration", + "interfaceModifier", "extendsInterfaces", "interfaceBody", "interfaceMemberDeclaration", + "constantDeclaration", "constantModifier", "interfaceMethodDeclaration", + "interfaceMethodModifier", "annotationTypeDeclaration", "annotationTypeBody", + "annotationTypeMemberDeclaration", "annotationTypeElementDeclaration", + "annotationTypeElementModifier", "defaultValue", "annotation", "normalAnnotation", + "elementValuePairList", "elementValuePair", "elementValue", "elementValueArrayInitializer", + "elementValueList", "markerAnnotation", "singleElementAnnotation", "arrayInitializer", + "variableInitializerList", "block", "blockStatements", "blockStatement", + "localVariableDeclarationStatement", "localVariableDeclaration", "statement", + "statementNoShortIf", "statementWithoutTrailingSubstatement", "emptyStatement", + "labeledStatement", "labeledStatementNoShortIf", "expressionStatement", + "statementExpression", "ifThenStatement", "ifThenElseStatement", "ifThenElseStatementNoShortIf", + "assertStatement", "switchStatement", "switchBlock", "switchBlockStatementGroup", + "switchLabels", "switchLabel", "enumConstantName", "whileStatement", "whileStatementNoShortIf", + "doStatement", "forStatement", "forStatementNoShortIf", "basicForStatement", + "basicForStatementNoShortIf", "forInit", "forUpdate", "statementExpressionList", + "enhancedForStatement", "enhancedForStatementNoShortIf", "breakStatement", + "continueStatement", "returnStatement", "throwStatement", "synchronizedStatement", + "tryStatement", "catches", "catchClause", "catchFormalParameter", "catchType", + "finally_", "tryWithResourcesStatement", "resourceSpecification", "resourceList", + "resource", "variableAccess", "primary", "primaryNoNewArray", "primaryNoNewArray_lf_arrayAccess", + "primaryNoNewArray_lfno_arrayAccess", "primaryNoNewArray_lf_primary", + "primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary", "primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary", + "primaryNoNewArray_lfno_primary", "primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary", + "primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary", "classLiteral", + "classInstanceCreationExpression", "classInstanceCreationExpression_lf_primary", + "classInstanceCreationExpression_lfno_primary", "typeArgumentsOrDiamond", + "fieldAccess", "fieldAccess_lf_primary", "fieldAccess_lfno_primary", "arrayAccess", + "arrayAccess_lf_primary", "arrayAccess_lfno_primary", "methodInvocation", + "methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList", + "methodReference", "methodReference_lf_primary", "methodReference_lfno_primary", + "arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression", + "expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList", + "lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator", + "conditionalExpression", "conditionalOrExpression", "conditionalAndExpression", + "inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression", + "relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression", + "unaryExpression", "preIncrementExpression", "preDecrementExpression", + "unaryExpressionNotPlusMinus", "postfixExpression", "postIncrementExpression", + "postIncrementExpression_lf_postfixExpression", "postDecrementExpression", + "postDecrementExpression_lf_postfixExpression", "castExpression", "identifier" + }; + + private static readonly string[] _LiteralNames = { + null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", + "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", + "'do'", "'double'", "'else'", "'enum'", "'exports'", "'extends'", "'final'", + "'finally'", "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", + "'instanceof'", "'int'", "'interface'", "'long'", "'module'", "'native'", + "'new'", "'open'", "'opens'", "'package'", "'private'", "'protected'", + "'provides'", "'public'", "'requires'", "'return'", "'short'", "'static'", + "'strictfp'", "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", + "'throws'", "'to'", "'transient'", "'transitive'", "'try'", "'uses'", + "'void'", "'volatile'", "'while'", "'with'", "'_'", null, null, null, + null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", "';'", + "','", "'.'", "'...'", "'@'", "'::'", "'='", "'>'", "'<'", "'!'", "'~'", + "'?'", "':'", "'->'", "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", + "'++'", "'--'", "'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", + "'+='", "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", + "'>>='", "'>>>='" + }; + private static readonly string[] _SymbolicNames = { + null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", + "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", + "ENUM", "EXPORTS", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", + "GOTO", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", + "MODULE", "NATIVE", "NEW", "OPEN", "OPENS", "PACKAGE", "PRIVATE", "PROTECTED", + "PROVIDES", "PUBLIC", "REQUIRES", "RETURN", "SHORT", "STATIC", "STRICTFP", + "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TO", "TRANSIENT", + "TRANSITIVE", "TRY", "USES", "VOID", "VOLATILE", "WHILE", "WITH", "UNDER_SCORE", + "IntegerLiteral", "FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", + "StringLiteral", "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", + "LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", "ELLIPSIS", "AT", "COLONCOLON", + "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "ARROW", "EQUAL", + "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", + "DIV", "BITAND", "BITOR", "CARET", "MOD", "ADD_ASSIGN", "SUB_ASSIGN", + "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", + "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", "WS", + "COMMENT", "LINE_COMMENT" + }; + public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames); + + [NotNull] + public override IVocabulary Vocabulary + { + get + { + return DefaultVocabulary; + } + } + + public override string GrammarFileName { get { return "Java9Parser.g4"; } } + + public override string[] RuleNames { get { return ruleNames; } } + + public override string SerializedAtn { get { return new string(_serializedATN); } } + + static Java9Parser() { + decisionToDFA = new DFA[_ATN.NumberOfDecisions]; + for (int i = 0; i < _ATN.NumberOfDecisions; i++) { + decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i); + } + } + + public Java9Parser(ITokenStream input) : this(input, Console.Out, Console.Error) { } + + public Java9Parser(ITokenStream input, TextWriter output, TextWriter errorOutput) + : base(input, output, errorOutput) + { + Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache); + } + + public partial class LiteralContext : ParserRuleContext { + public ITerminalNode IntegerLiteral() { return GetToken(Java9Parser.IntegerLiteral, 0); } + public ITerminalNode FloatingPointLiteral() { return GetToken(Java9Parser.FloatingPointLiteral, 0); } + public ITerminalNode BooleanLiteral() { return GetToken(Java9Parser.BooleanLiteral, 0); } + public ITerminalNode CharacterLiteral() { return GetToken(Java9Parser.CharacterLiteral, 0); } + public ITerminalNode StringLiteral() { return GetToken(Java9Parser.StringLiteral, 0); } + public ITerminalNode NullLiteral() { return GetToken(Java9Parser.NullLiteral, 0); } + public LiteralContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_literal; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterLiteral(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitLiteral(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitLiteral(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public LiteralContext literal() { + LiteralContext _localctx = new LiteralContext(Context, State); + EnterRule(_localctx, 0, RULE_literal); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 490; + _la = TokenStream.LA(1); + if ( !(((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & ((1L << (IntegerLiteral - 62)) | (1L << (FloatingPointLiteral - 62)) | (1L << (BooleanLiteral - 62)) | (1L << (CharacterLiteral - 62)) | (1L << (StringLiteral - 62)) | (1L << (NullLiteral - 62)))) != 0)) ) { + ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PrimitiveTypeContext : ParserRuleContext { + public NumericTypeContext numericType() { + return GetRuleContext(0); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public ITerminalNode BOOLEAN() { return GetToken(Java9Parser.BOOLEAN, 0); } + public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_primitiveType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPrimitiveType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPrimitiveType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPrimitiveType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PrimitiveTypeContext primitiveType() { + PrimitiveTypeContext _localctx = new PrimitiveTypeContext(Context, State); + EnterRule(_localctx, 2, RULE_primitiveType); + int _la; + try { + State = 506; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,2,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 495; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 492; annotation(); + } + } + State = 497; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 498; numericType(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 502; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 499; annotation(); + } + } + State = 504; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 505; Match(BOOLEAN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class NumericTypeContext : ParserRuleContext { + public IntegralTypeContext integralType() { + return GetRuleContext(0); + } + public FloatingPointTypeContext floatingPointType() { + return GetRuleContext(0); + } + public NumericTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_numericType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterNumericType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitNumericType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitNumericType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public NumericTypeContext numericType() { + NumericTypeContext _localctx = new NumericTypeContext(Context, State); + EnterRule(_localctx, 4, RULE_numericType); + try { + State = 510; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case BYTE: + case CHAR: + case INT: + case LONG: + case SHORT: + EnterOuterAlt(_localctx, 1); + { + State = 508; integralType(); + } + break; + case DOUBLE: + case FLOAT: + EnterOuterAlt(_localctx, 2); + { + State = 509; floatingPointType(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class IntegralTypeContext : ParserRuleContext { + public ITerminalNode BYTE() { return GetToken(Java9Parser.BYTE, 0); } + public ITerminalNode SHORT() { return GetToken(Java9Parser.SHORT, 0); } + public ITerminalNode INT() { return GetToken(Java9Parser.INT, 0); } + public ITerminalNode LONG() { return GetToken(Java9Parser.LONG, 0); } + public ITerminalNode CHAR() { return GetToken(Java9Parser.CHAR, 0); } + public IntegralTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_integralType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterIntegralType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitIntegralType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitIntegralType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public IntegralTypeContext integralType() { + IntegralTypeContext _localctx = new IntegralTypeContext(Context, State); + EnterRule(_localctx, 6, RULE_integralType); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 512; + _la = TokenStream.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << CHAR) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0)) ) { + ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class FloatingPointTypeContext : ParserRuleContext { + public ITerminalNode FLOAT() { return GetToken(Java9Parser.FLOAT, 0); } + public ITerminalNode DOUBLE() { return GetToken(Java9Parser.DOUBLE, 0); } + public FloatingPointTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_floatingPointType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterFloatingPointType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitFloatingPointType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitFloatingPointType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public FloatingPointTypeContext floatingPointType() { + FloatingPointTypeContext _localctx = new FloatingPointTypeContext(Context, State); + EnterRule(_localctx, 8, RULE_floatingPointType); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 514; + _la = TokenStream.LA(1); + if ( !(_la==DOUBLE || _la==FLOAT) ) { + ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ReferenceTypeContext : ParserRuleContext { + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return GetRuleContext(0); + } + public TypeVariableContext typeVariable() { + return GetRuleContext(0); + } + public ArrayTypeContext arrayType() { + return GetRuleContext(0); + } + public ReferenceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_referenceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterReferenceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitReferenceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitReferenceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ReferenceTypeContext referenceType() { + ReferenceTypeContext _localctx = new ReferenceTypeContext(Context, State); + EnterRule(_localctx, 10, RULE_referenceType); + try { + State = 519; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,4,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 516; classOrInterfaceType(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 517; typeVariable(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 518; arrayType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassOrInterfaceTypeContext : ParserRuleContext { + public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() { + return GetRuleContext(0); + } + public InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() { + return GetRuleContext(0); + } + public ClassType_lf_classOrInterfaceTypeContext[] classType_lf_classOrInterfaceType() { + return GetRuleContexts(); + } + public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType(int i) { + return GetRuleContext(i); + } + public InterfaceType_lf_classOrInterfaceTypeContext[] interfaceType_lf_classOrInterfaceType() { + return GetRuleContexts(); + } + public InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType(int i) { + return GetRuleContext(i); + } + public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classOrInterfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassOrInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassOrInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassOrInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassOrInterfaceTypeContext classOrInterfaceType() { + ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(Context, State); + EnterRule(_localctx, 12, RULE_classOrInterfaceType); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 523; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) { + case 1: + { + State = 521; classType_lfno_classOrInterfaceType(); + } + break; + case 2: + { + State = 522; interfaceType_lfno_classOrInterfaceType(); + } + break; + } + State = 529; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,7,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + State = 527; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,6,Context) ) { + case 1: + { + State = 525; classType_lf_classOrInterfaceType(); + } + break; + case 2: + { + State = 526; interfaceType_lf_classOrInterfaceType(); + } + break; + } + } + } + State = 531; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,7,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassTypeContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ClassTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassTypeContext classType() { + ClassTypeContext _localctx = new ClassTypeContext(Context, State); + EnterRule(_localctx, 14, RULE_classType); + int _la; + try { + State = 554; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,12,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 535; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 532; annotation(); + } + } + State = 537; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 538; identifier(); + State = 540; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 539; typeArguments(); + } + } + + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 542; classOrInterfaceType(); + State = 543; Match(DOT); + State = 547; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 544; annotation(); + } + } + State = 549; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 550; identifier(); + State = 552; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 551; typeArguments(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassType_lf_classOrInterfaceTypeContext : ParserRuleContext { + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public ClassType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classType_lf_classOrInterfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassType_lf_classOrInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassType_lf_classOrInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassType_lf_classOrInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() { + ClassType_lf_classOrInterfaceTypeContext _localctx = new ClassType_lf_classOrInterfaceTypeContext(Context, State); + EnterRule(_localctx, 16, RULE_classType_lf_classOrInterfaceType); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 556; Match(DOT); + State = 560; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 557; annotation(); + } + } + State = 562; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 563; identifier(); + State = 565; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,14,Context) ) { + case 1: + { + State = 564; typeArguments(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassType_lfno_classOrInterfaceTypeContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public ClassType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classType_lfno_classOrInterfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassType_lfno_classOrInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassType_lfno_classOrInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassType_lfno_classOrInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() { + ClassType_lfno_classOrInterfaceTypeContext _localctx = new ClassType_lfno_classOrInterfaceTypeContext(Context, State); + EnterRule(_localctx, 18, RULE_classType_lfno_classOrInterfaceType); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 570; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 567; annotation(); + } + } + State = 572; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 573; identifier(); + State = 575; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,16,Context) ) { + case 1: + { + State = 574; typeArguments(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InterfaceTypeContext : ParserRuleContext { + public ClassTypeContext classType() { + return GetRuleContext(0); + } + public InterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_interfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InterfaceTypeContext interfaceType() { + InterfaceTypeContext _localctx = new InterfaceTypeContext(Context, State); + EnterRule(_localctx, 20, RULE_interfaceType); + try { + EnterOuterAlt(_localctx, 1); + { + State = 577; classType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InterfaceType_lf_classOrInterfaceTypeContext : ParserRuleContext { + public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() { + return GetRuleContext(0); + } + public InterfaceType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_interfaceType_lf_classOrInterfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInterfaceType_lf_classOrInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInterfaceType_lf_classOrInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInterfaceType_lf_classOrInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType() { + InterfaceType_lf_classOrInterfaceTypeContext _localctx = new InterfaceType_lf_classOrInterfaceTypeContext(Context, State); + EnterRule(_localctx, 22, RULE_interfaceType_lf_classOrInterfaceType); + try { + EnterOuterAlt(_localctx, 1); + { + State = 579; classType_lf_classOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InterfaceType_lfno_classOrInterfaceTypeContext : ParserRuleContext { + public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() { + return GetRuleContext(0); + } + public InterfaceType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_interfaceType_lfno_classOrInterfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInterfaceType_lfno_classOrInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInterfaceType_lfno_classOrInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInterfaceType_lfno_classOrInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() { + InterfaceType_lfno_classOrInterfaceTypeContext _localctx = new InterfaceType_lfno_classOrInterfaceTypeContext(Context, State); + EnterRule(_localctx, 24, RULE_interfaceType_lfno_classOrInterfaceType); + try { + EnterOuterAlt(_localctx, 1); + { + State = 581; classType_lfno_classOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeVariableContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public TypeVariableContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeVariable; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeVariable(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeVariable(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeVariable(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeVariableContext typeVariable() { + TypeVariableContext _localctx = new TypeVariableContext(Context, State); + EnterRule(_localctx, 26, RULE_typeVariable); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 586; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 583; annotation(); + } + } + State = 588; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 589; identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ArrayTypeContext : ParserRuleContext { + public PrimitiveTypeContext primitiveType() { + return GetRuleContext(0); + } + public DimsContext dims() { + return GetRuleContext(0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return GetRuleContext(0); + } + public TypeVariableContext typeVariable() { + return GetRuleContext(0); + } + public ArrayTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_arrayType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterArrayType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitArrayType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitArrayType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ArrayTypeContext arrayType() { + ArrayTypeContext _localctx = new ArrayTypeContext(Context, State); + EnterRule(_localctx, 28, RULE_arrayType); + try { + State = 600; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,18,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 591; primitiveType(); + State = 592; dims(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 594; classOrInterfaceType(); + State = 595; dims(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 597; typeVariable(); + State = 598; dims(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class DimsContext : ParserRuleContext { + public ITerminalNode[] LBRACK() { return GetTokens(Java9Parser.LBRACK); } + public ITerminalNode LBRACK(int i) { + return GetToken(Java9Parser.LBRACK, i); + } + public ITerminalNode[] RBRACK() { return GetTokens(Java9Parser.RBRACK); } + public ITerminalNode RBRACK(int i) { + return GetToken(Java9Parser.RBRACK, i); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public DimsContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_dims; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterDims(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitDims(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitDims(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public DimsContext dims() { + DimsContext _localctx = new DimsContext(Context, State); + EnterRule(_localctx, 30, RULE_dims); + int _la; + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 605; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 602; annotation(); + } + } + State = 607; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 608; Match(LBRACK); + State = 609; Match(RBRACK); + State = 620; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,21,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 613; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 610; annotation(); + } + } + State = 615; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 616; Match(LBRACK); + State = 617; Match(RBRACK); + } + } + } + State = 622; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,21,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeParameterContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public TypeParameterModifierContext[] typeParameterModifier() { + return GetRuleContexts(); + } + public TypeParameterModifierContext typeParameterModifier(int i) { + return GetRuleContext(i); + } + public TypeBoundContext typeBound() { + return GetRuleContext(0); + } + public TypeParameterContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeParameter; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeParameter(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeParameter(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeParameter(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeParameterContext typeParameter() { + TypeParameterContext _localctx = new TypeParameterContext(Context, State); + EnterRule(_localctx, 32, RULE_typeParameter); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 626; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 623; typeParameterModifier(); + } + } + State = 628; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 629; identifier(); + State = 631; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==EXTENDS) { + { + State = 630; typeBound(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeParameterModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeParameterModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeParameterModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeParameterModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeParameterModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeParameterModifierContext typeParameterModifier() { + TypeParameterModifierContext _localctx = new TypeParameterModifierContext(Context, State); + EnterRule(_localctx, 34, RULE_typeParameterModifier); + try { + EnterOuterAlt(_localctx, 1); + { + State = 633; annotation(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeBoundContext : ParserRuleContext { + public ITerminalNode EXTENDS() { return GetToken(Java9Parser.EXTENDS, 0); } + public TypeVariableContext typeVariable() { + return GetRuleContext(0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return GetRuleContext(0); + } + public AdditionalBoundContext[] additionalBound() { + return GetRuleContexts(); + } + public AdditionalBoundContext additionalBound(int i) { + return GetRuleContext(i); + } + public TypeBoundContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeBound; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeBound(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeBound(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeBound(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeBoundContext typeBound() { + TypeBoundContext _localctx = new TypeBoundContext(Context, State); + EnterRule(_localctx, 36, RULE_typeBound); + int _la; + try { + State = 645; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,25,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 635; Match(EXTENDS); + State = 636; typeVariable(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 637; Match(EXTENDS); + State = 638; classOrInterfaceType(); + State = 642; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==BITAND) { + { + { + State = 639; additionalBound(); + } + } + State = 644; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AdditionalBoundContext : ParserRuleContext { + public ITerminalNode BITAND() { return GetToken(Java9Parser.BITAND, 0); } + public InterfaceTypeContext interfaceType() { + return GetRuleContext(0); + } + public AdditionalBoundContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_additionalBound; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAdditionalBound(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAdditionalBound(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAdditionalBound(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AdditionalBoundContext additionalBound() { + AdditionalBoundContext _localctx = new AdditionalBoundContext(Context, State); + EnterRule(_localctx, 38, RULE_additionalBound); + try { + EnterOuterAlt(_localctx, 1); + { + State = 647; Match(BITAND); + State = 648; interfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeArgumentsContext : ParserRuleContext { + public ITerminalNode LT() { return GetToken(Java9Parser.LT, 0); } + public TypeArgumentListContext typeArgumentList() { + return GetRuleContext(0); + } + public ITerminalNode GT() { return GetToken(Java9Parser.GT, 0); } + public TypeArgumentsContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeArguments; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeArguments(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeArguments(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeArguments(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeArgumentsContext typeArguments() { + TypeArgumentsContext _localctx = new TypeArgumentsContext(Context, State); + EnterRule(_localctx, 40, RULE_typeArguments); + try { + EnterOuterAlt(_localctx, 1); + { + State = 650; Match(LT); + State = 651; typeArgumentList(); + State = 652; Match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeArgumentListContext : ParserRuleContext { + public TypeArgumentContext[] typeArgument() { + return GetRuleContexts(); + } + public TypeArgumentContext typeArgument(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public TypeArgumentListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeArgumentList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeArgumentList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeArgumentList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeArgumentList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeArgumentListContext typeArgumentList() { + TypeArgumentListContext _localctx = new TypeArgumentListContext(Context, State); + EnterRule(_localctx, 42, RULE_typeArgumentList); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 654; typeArgument(); + State = 659; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 655; Match(COMMA); + State = 656; typeArgument(); + } + } + State = 661; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeArgumentContext : ParserRuleContext { + public ReferenceTypeContext referenceType() { + return GetRuleContext(0); + } + public WildcardContext wildcard() { + return GetRuleContext(0); + } + public TypeArgumentContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeArgument; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeArgument(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeArgument(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeArgument(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeArgumentContext typeArgument() { + TypeArgumentContext _localctx = new TypeArgumentContext(Context, State); + EnterRule(_localctx, 44, RULE_typeArgument); + try { + State = 664; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,27,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 662; referenceType(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 663; wildcard(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class WildcardContext : ParserRuleContext { + public ITerminalNode QUESTION() { return GetToken(Java9Parser.QUESTION, 0); } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public WildcardBoundsContext wildcardBounds() { + return GetRuleContext(0); + } + public WildcardContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_wildcard; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterWildcard(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitWildcard(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitWildcard(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public WildcardContext wildcard() { + WildcardContext _localctx = new WildcardContext(Context, State); + EnterRule(_localctx, 46, RULE_wildcard); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 669; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 666; annotation(); + } + } + State = 671; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 672; Match(QUESTION); + State = 674; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==EXTENDS || _la==SUPER) { + { + State = 673; wildcardBounds(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class WildcardBoundsContext : ParserRuleContext { + public ITerminalNode EXTENDS() { return GetToken(Java9Parser.EXTENDS, 0); } + public ReferenceTypeContext referenceType() { + return GetRuleContext(0); + } + public ITerminalNode SUPER() { return GetToken(Java9Parser.SUPER, 0); } + public WildcardBoundsContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_wildcardBounds; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterWildcardBounds(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitWildcardBounds(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitWildcardBounds(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public WildcardBoundsContext wildcardBounds() { + WildcardBoundsContext _localctx = new WildcardBoundsContext(Context, State); + EnterRule(_localctx, 48, RULE_wildcardBounds); + try { + State = 680; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case EXTENDS: + EnterOuterAlt(_localctx, 1); + { + State = 676; Match(EXTENDS); + State = 677; referenceType(); + } + break; + case SUPER: + EnterOuterAlt(_localctx, 2); + { + State = 678; Match(SUPER); + State = 679; referenceType(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ModuleNameContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ModuleNameContext moduleName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ModuleNameContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_moduleName; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterModuleName(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitModuleName(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitModuleName(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ModuleNameContext moduleName() { + return moduleName(0); + } + + private ModuleNameContext moduleName(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + ModuleNameContext _localctx = new ModuleNameContext(Context, _parentState); + ModuleNameContext _prevctx = _localctx; + int _startState = 50; + EnterRecursionRule(_localctx, 50, RULE_moduleName, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 683; identifier(); + } + Context.Stop = TokenStream.LT(-1); + State = 690; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,31,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new ModuleNameContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_moduleName); + State = 685; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 686; Match(DOT); + State = 687; identifier(); + } + } + } + State = 692; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,31,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class PackageNameContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public PackageNameContext packageName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public PackageNameContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_packageName; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPackageName(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPackageName(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPackageName(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PackageNameContext packageName() { + return packageName(0); + } + + private PackageNameContext packageName(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + PackageNameContext _localctx = new PackageNameContext(Context, _parentState); + PackageNameContext _prevctx = _localctx; + int _startState = 52; + EnterRecursionRule(_localctx, 52, RULE_packageName, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 694; identifier(); + } + Context.Stop = TokenStream.LT(-1); + State = 701; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,32,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new PackageNameContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_packageName); + State = 696; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 697; Match(DOT); + State = 698; identifier(); + } + } + } + State = 703; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,32,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class TypeNameContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public PackageOrTypeNameContext packageOrTypeName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public TypeNameContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeName; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeName(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeName(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeName(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeNameContext typeName() { + TypeNameContext _localctx = new TypeNameContext(Context, State); + EnterRule(_localctx, 54, RULE_typeName); + try { + State = 709; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,33,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 704; identifier(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 705; packageOrTypeName(0); + State = 706; Match(DOT); + State = 707; identifier(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PackageOrTypeNameContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public PackageOrTypeNameContext packageOrTypeName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public PackageOrTypeNameContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_packageOrTypeName; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPackageOrTypeName(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPackageOrTypeName(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPackageOrTypeName(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PackageOrTypeNameContext packageOrTypeName() { + return packageOrTypeName(0); + } + + private PackageOrTypeNameContext packageOrTypeName(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + PackageOrTypeNameContext _localctx = new PackageOrTypeNameContext(Context, _parentState); + PackageOrTypeNameContext _prevctx = _localctx; + int _startState = 56; + EnterRecursionRule(_localctx, 56, RULE_packageOrTypeName, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 712; identifier(); + } + Context.Stop = TokenStream.LT(-1); + State = 719; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,34,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new PackageOrTypeNameContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_packageOrTypeName); + State = 714; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 715; Match(DOT); + State = 716; identifier(); + } + } + } + State = 721; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,34,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class ExpressionNameContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public AmbiguousNameContext ambiguousName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ExpressionNameContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_expressionName; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterExpressionName(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitExpressionName(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitExpressionName(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ExpressionNameContext expressionName() { + ExpressionNameContext _localctx = new ExpressionNameContext(Context, State); + EnterRule(_localctx, 58, RULE_expressionName); + try { + State = 727; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 722; identifier(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 723; ambiguousName(0); + State = 724; Match(DOT); + State = 725; identifier(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodNameContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public MethodNameContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodName; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodName(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodName(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodName(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodNameContext methodName() { + MethodNameContext _localctx = new MethodNameContext(Context, State); + EnterRule(_localctx, 60, RULE_methodName); + try { + EnterOuterAlt(_localctx, 1); + { + State = 729; identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AmbiguousNameContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public AmbiguousNameContext ambiguousName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public AmbiguousNameContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_ambiguousName; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAmbiguousName(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAmbiguousName(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAmbiguousName(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AmbiguousNameContext ambiguousName() { + return ambiguousName(0); + } + + private AmbiguousNameContext ambiguousName(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + AmbiguousNameContext _localctx = new AmbiguousNameContext(Context, _parentState); + AmbiguousNameContext _prevctx = _localctx; + int _startState = 62; + EnterRecursionRule(_localctx, 62, RULE_ambiguousName, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 732; identifier(); + } + Context.Stop = TokenStream.LT(-1); + State = 739; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,36,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new AmbiguousNameContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_ambiguousName); + State = 734; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 735; Match(DOT); + State = 736; identifier(); + } + } + } + State = 741; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,36,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class CompilationUnitContext : ParserRuleContext { + public OrdinaryCompilationContext ordinaryCompilation() { + return GetRuleContext(0); + } + public ModularCompilationContext modularCompilation() { + return GetRuleContext(0); + } + public CompilationUnitContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_compilationUnit; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterCompilationUnit(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitCompilationUnit(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitCompilationUnit(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public CompilationUnitContext compilationUnit() { + CompilationUnitContext _localctx = new CompilationUnitContext(Context, State); + EnterRule(_localctx, 64, RULE_compilationUnit); + try { + State = 744; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 742; ordinaryCompilation(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 743; modularCompilation(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class OrdinaryCompilationContext : ParserRuleContext { + public ITerminalNode Eof() { return GetToken(Java9Parser.Eof, 0); } + public PackageDeclarationContext packageDeclaration() { + return GetRuleContext(0); + } + public ImportDeclarationContext[] importDeclaration() { + return GetRuleContexts(); + } + public ImportDeclarationContext importDeclaration(int i) { + return GetRuleContext(i); + } + public TypeDeclarationContext[] typeDeclaration() { + return GetRuleContexts(); + } + public TypeDeclarationContext typeDeclaration(int i) { + return GetRuleContext(i); + } + public OrdinaryCompilationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_ordinaryCompilation; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterOrdinaryCompilation(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitOrdinaryCompilation(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitOrdinaryCompilation(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public OrdinaryCompilationContext ordinaryCompilation() { + OrdinaryCompilationContext _localctx = new OrdinaryCompilationContext(Context, State); + EnterRule(_localctx, 66, RULE_ordinaryCompilation); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 747; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,38,Context) ) { + case 1: + { + State = 746; packageDeclaration(); + } + break; + } + State = 752; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==IMPORT) { + { + { + State = 749; importDeclaration(); + } + } + State = 754; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 758; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==SEMI || _la==AT) { + { + { + State = 755; typeDeclaration(); + } + } + State = 760; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 761; Match(Eof); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ModularCompilationContext : ParserRuleContext { + public ModuleDeclarationContext moduleDeclaration() { + return GetRuleContext(0); + } + public ImportDeclarationContext[] importDeclaration() { + return GetRuleContexts(); + } + public ImportDeclarationContext importDeclaration(int i) { + return GetRuleContext(i); + } + public ModularCompilationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_modularCompilation; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterModularCompilation(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitModularCompilation(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitModularCompilation(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ModularCompilationContext modularCompilation() { + ModularCompilationContext _localctx = new ModularCompilationContext(Context, State); + EnterRule(_localctx, 68, RULE_modularCompilation); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 766; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==IMPORT) { + { + { + State = 763; importDeclaration(); + } + } + State = 768; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 769; moduleDeclaration(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PackageDeclarationContext : ParserRuleContext { + public ITerminalNode PACKAGE() { return GetToken(Java9Parser.PACKAGE, 0); } + public PackageNameContext packageName() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public PackageModifierContext[] packageModifier() { + return GetRuleContexts(); + } + public PackageModifierContext packageModifier(int i) { + return GetRuleContext(i); + } + public PackageDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_packageDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPackageDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPackageDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPackageDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PackageDeclarationContext packageDeclaration() { + PackageDeclarationContext _localctx = new PackageDeclarationContext(Context, State); + EnterRule(_localctx, 70, RULE_packageDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 774; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 771; packageModifier(); + } + } + State = 776; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 777; Match(PACKAGE); + State = 778; packageName(0); + State = 779; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PackageModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public PackageModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_packageModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPackageModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPackageModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPackageModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PackageModifierContext packageModifier() { + PackageModifierContext _localctx = new PackageModifierContext(Context, State); + EnterRule(_localctx, 72, RULE_packageModifier); + try { + EnterOuterAlt(_localctx, 1); + { + State = 781; annotation(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ImportDeclarationContext : ParserRuleContext { + public SingleTypeImportDeclarationContext singleTypeImportDeclaration() { + return GetRuleContext(0); + } + public TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() { + return GetRuleContext(0); + } + public SingleStaticImportDeclarationContext singleStaticImportDeclaration() { + return GetRuleContext(0); + } + public StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() { + return GetRuleContext(0); + } + public ImportDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_importDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterImportDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitImportDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitImportDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ImportDeclarationContext importDeclaration() { + ImportDeclarationContext _localctx = new ImportDeclarationContext(Context, State); + EnterRule(_localctx, 74, RULE_importDeclaration); + try { + State = 787; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,43,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 783; singleTypeImportDeclaration(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 784; typeImportOnDemandDeclaration(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 785; singleStaticImportDeclaration(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 786; staticImportOnDemandDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SingleTypeImportDeclarationContext : ParserRuleContext { + public ITerminalNode IMPORT() { return GetToken(Java9Parser.IMPORT, 0); } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public SingleTypeImportDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_singleTypeImportDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSingleTypeImportDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSingleTypeImportDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSingleTypeImportDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SingleTypeImportDeclarationContext singleTypeImportDeclaration() { + SingleTypeImportDeclarationContext _localctx = new SingleTypeImportDeclarationContext(Context, State); + EnterRule(_localctx, 76, RULE_singleTypeImportDeclaration); + try { + EnterOuterAlt(_localctx, 1); + { + State = 789; Match(IMPORT); + State = 790; typeName(); + State = 791; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeImportOnDemandDeclarationContext : ParserRuleContext { + public ITerminalNode IMPORT() { return GetToken(Java9Parser.IMPORT, 0); } + public PackageOrTypeNameContext packageOrTypeName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ITerminalNode MUL() { return GetToken(Java9Parser.MUL, 0); } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public TypeImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeImportOnDemandDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeImportOnDemandDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeImportOnDemandDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeImportOnDemandDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() { + TypeImportOnDemandDeclarationContext _localctx = new TypeImportOnDemandDeclarationContext(Context, State); + EnterRule(_localctx, 78, RULE_typeImportOnDemandDeclaration); + try { + EnterOuterAlt(_localctx, 1); + { + State = 793; Match(IMPORT); + State = 794; packageOrTypeName(0); + State = 795; Match(DOT); + State = 796; Match(MUL); + State = 797; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SingleStaticImportDeclarationContext : ParserRuleContext { + public ITerminalNode IMPORT() { return GetToken(Java9Parser.IMPORT, 0); } + public ITerminalNode STATIC() { return GetToken(Java9Parser.STATIC, 0); } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public SingleStaticImportDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_singleStaticImportDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSingleStaticImportDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSingleStaticImportDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSingleStaticImportDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SingleStaticImportDeclarationContext singleStaticImportDeclaration() { + SingleStaticImportDeclarationContext _localctx = new SingleStaticImportDeclarationContext(Context, State); + EnterRule(_localctx, 80, RULE_singleStaticImportDeclaration); + try { + EnterOuterAlt(_localctx, 1); + { + State = 799; Match(IMPORT); + State = 800; Match(STATIC); + State = 801; typeName(); + State = 802; Match(DOT); + State = 803; identifier(); + State = 804; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class StaticImportOnDemandDeclarationContext : ParserRuleContext { + public ITerminalNode IMPORT() { return GetToken(Java9Parser.IMPORT, 0); } + public ITerminalNode STATIC() { return GetToken(Java9Parser.STATIC, 0); } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ITerminalNode MUL() { return GetToken(Java9Parser.MUL, 0); } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public StaticImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_staticImportOnDemandDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterStaticImportOnDemandDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitStaticImportOnDemandDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitStaticImportOnDemandDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() { + StaticImportOnDemandDeclarationContext _localctx = new StaticImportOnDemandDeclarationContext(Context, State); + EnterRule(_localctx, 82, RULE_staticImportOnDemandDeclaration); + try { + EnterOuterAlt(_localctx, 1); + { + State = 806; Match(IMPORT); + State = 807; Match(STATIC); + State = 808; typeName(); + State = 809; Match(DOT); + State = 810; Match(MUL); + State = 811; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeDeclarationContext : ParserRuleContext { + public ClassDeclarationContext classDeclaration() { + return GetRuleContext(0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public TypeDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeDeclarationContext typeDeclaration() { + TypeDeclarationContext _localctx = new TypeDeclarationContext(Context, State); + EnterRule(_localctx, 84, RULE_typeDeclaration); + try { + State = 816; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,44,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 813; classDeclaration(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 814; interfaceDeclaration(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 815; Match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ModuleDeclarationContext : ParserRuleContext { + public ITerminalNode MODULE() { return GetToken(Java9Parser.MODULE, 0); } + public ModuleNameContext moduleName() { + return GetRuleContext(0); + } + public ITerminalNode LBRACE() { return GetToken(Java9Parser.LBRACE, 0); } + public ITerminalNode RBRACE() { return GetToken(Java9Parser.RBRACE, 0); } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public ITerminalNode OPEN() { return GetToken(Java9Parser.OPEN, 0); } + public ModuleDirectiveContext[] moduleDirective() { + return GetRuleContexts(); + } + public ModuleDirectiveContext moduleDirective(int i) { + return GetRuleContext(i); + } + public ModuleDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_moduleDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterModuleDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitModuleDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitModuleDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ModuleDeclarationContext moduleDeclaration() { + ModuleDeclarationContext _localctx = new ModuleDeclarationContext(Context, State); + EnterRule(_localctx, 86, RULE_moduleDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 821; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 818; annotation(); + } + } + State = 823; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 825; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==OPEN) { + { + State = 824; Match(OPEN); + } + } + + State = 827; Match(MODULE); + State = 828; moduleName(0); + State = 829; Match(LBRACE); + State = 833; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXPORTS) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << USES))) != 0)) { + { + { + State = 830; moduleDirective(); + } + } + State = 835; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 836; Match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ModuleDirectiveContext : ParserRuleContext { + public ITerminalNode REQUIRES() { return GetToken(Java9Parser.REQUIRES, 0); } + public ModuleNameContext[] moduleName() { + return GetRuleContexts(); + } + public ModuleNameContext moduleName(int i) { + return GetRuleContext(i); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public RequiresModifierContext[] requiresModifier() { + return GetRuleContexts(); + } + public RequiresModifierContext requiresModifier(int i) { + return GetRuleContext(i); + } + public ITerminalNode EXPORTS() { return GetToken(Java9Parser.EXPORTS, 0); } + public PackageNameContext packageName() { + return GetRuleContext(0); + } + public ITerminalNode TO() { return GetToken(Java9Parser.TO, 0); } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public ITerminalNode OPENS() { return GetToken(Java9Parser.OPENS, 0); } + public ITerminalNode USES() { return GetToken(Java9Parser.USES, 0); } + public TypeNameContext[] typeName() { + return GetRuleContexts(); + } + public TypeNameContext typeName(int i) { + return GetRuleContext(i); + } + public ITerminalNode PROVIDES() { return GetToken(Java9Parser.PROVIDES, 0); } + public ITerminalNode WITH() { return GetToken(Java9Parser.WITH, 0); } + public ModuleDirectiveContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_moduleDirective; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterModuleDirective(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitModuleDirective(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitModuleDirective(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ModuleDirectiveContext moduleDirective() { + ModuleDirectiveContext _localctx = new ModuleDirectiveContext(Context, State); + EnterRule(_localctx, 88, RULE_moduleDirective); + int _la; + try { + State = 895; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case REQUIRES: + EnterOuterAlt(_localctx, 1); + { + State = 838; Match(REQUIRES); + State = 842; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==STATIC || _la==TRANSITIVE) { + { + { + State = 839; requiresModifier(); + } + } + State = 844; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 845; moduleName(0); + State = 846; Match(SEMI); + } + break; + case EXPORTS: + EnterOuterAlt(_localctx, 2); + { + State = 848; Match(EXPORTS); + State = 849; packageName(0); + State = 859; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==TO) { + { + State = 850; Match(TO); + State = 851; moduleName(0); + State = 856; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 852; Match(COMMA); + State = 853; moduleName(0); + } + } + State = 858; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + + State = 861; Match(SEMI); + } + break; + case OPENS: + EnterOuterAlt(_localctx, 3); + { + State = 863; Match(OPENS); + State = 864; packageName(0); + State = 874; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==TO) { + { + State = 865; Match(TO); + State = 866; moduleName(0); + State = 871; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 867; Match(COMMA); + State = 868; moduleName(0); + } + } + State = 873; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + + State = 876; Match(SEMI); + } + break; + case USES: + EnterOuterAlt(_localctx, 4); + { + State = 878; Match(USES); + State = 879; typeName(); + State = 880; Match(SEMI); + } + break; + case PROVIDES: + EnterOuterAlt(_localctx, 5); + { + State = 882; Match(PROVIDES); + State = 883; typeName(); + State = 884; Match(WITH); + State = 885; typeName(); + State = 890; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 886; Match(COMMA); + State = 887; typeName(); + } + } + State = 892; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 893; Match(SEMI); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class RequiresModifierContext : ParserRuleContext { + public ITerminalNode TRANSITIVE() { return GetToken(Java9Parser.TRANSITIVE, 0); } + public ITerminalNode STATIC() { return GetToken(Java9Parser.STATIC, 0); } + public RequiresModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_requiresModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterRequiresModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitRequiresModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitRequiresModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public RequiresModifierContext requiresModifier() { + RequiresModifierContext _localctx = new RequiresModifierContext(Context, State); + EnterRule(_localctx, 90, RULE_requiresModifier); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 897; + _la = TokenStream.LA(1); + if ( !(_la==STATIC || _la==TRANSITIVE) ) { + ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassDeclarationContext : ParserRuleContext { + public NormalClassDeclarationContext normalClassDeclaration() { + return GetRuleContext(0); + } + public EnumDeclarationContext enumDeclaration() { + return GetRuleContext(0); + } + public ClassDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassDeclarationContext classDeclaration() { + ClassDeclarationContext _localctx = new ClassDeclarationContext(Context, State); + EnterRule(_localctx, 92, RULE_classDeclaration); + try { + State = 901; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 899; normalClassDeclaration(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 900; enumDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class NormalClassDeclarationContext : ParserRuleContext { + public ITerminalNode CLASS() { return GetToken(Java9Parser.CLASS, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ClassBodyContext classBody() { + return GetRuleContext(0); + } + public ClassModifierContext[] classModifier() { + return GetRuleContexts(); + } + public ClassModifierContext classModifier(int i) { + return GetRuleContext(i); + } + public TypeParametersContext typeParameters() { + return GetRuleContext(0); + } + public SuperclassContext superclass() { + return GetRuleContext(0); + } + public SuperinterfacesContext superinterfaces() { + return GetRuleContext(0); + } + public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_normalClassDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterNormalClassDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitNormalClassDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitNormalClassDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public NormalClassDeclarationContext normalClassDeclaration() { + NormalClassDeclarationContext _localctx = new NormalClassDeclarationContext(Context, State); + EnterRule(_localctx, 94, RULE_normalClassDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 906; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + State = 903; classModifier(); + } + } + State = 908; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 909; Match(CLASS); + State = 910; identifier(); + State = 912; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 911; typeParameters(); + } + } + + State = 915; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==EXTENDS) { + { + State = 914; superclass(); + } + } + + State = 918; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==IMPLEMENTS) { + { + State = 917; superinterfaces(); + } + } + + State = 920; classBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public ITerminalNode PUBLIC() { return GetToken(Java9Parser.PUBLIC, 0); } + public ITerminalNode PROTECTED() { return GetToken(Java9Parser.PROTECTED, 0); } + public ITerminalNode PRIVATE() { return GetToken(Java9Parser.PRIVATE, 0); } + public ITerminalNode ABSTRACT() { return GetToken(Java9Parser.ABSTRACT, 0); } + public ITerminalNode STATIC() { return GetToken(Java9Parser.STATIC, 0); } + public ITerminalNode FINAL() { return GetToken(Java9Parser.FINAL, 0); } + public ITerminalNode STRICTFP() { return GetToken(Java9Parser.STRICTFP, 0); } + public ClassModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassModifierContext classModifier() { + ClassModifierContext _localctx = new ClassModifierContext(Context, State); + EnterRule(_localctx, 96, RULE_classModifier); + try { + State = 930; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case AT: + EnterOuterAlt(_localctx, 1); + { + State = 922; annotation(); + } + break; + case PUBLIC: + EnterOuterAlt(_localctx, 2); + { + State = 923; Match(PUBLIC); + } + break; + case PROTECTED: + EnterOuterAlt(_localctx, 3); + { + State = 924; Match(PROTECTED); + } + break; + case PRIVATE: + EnterOuterAlt(_localctx, 4); + { + State = 925; Match(PRIVATE); + } + break; + case ABSTRACT: + EnterOuterAlt(_localctx, 5); + { + State = 926; Match(ABSTRACT); + } + break; + case STATIC: + EnterOuterAlt(_localctx, 6); + { + State = 927; Match(STATIC); + } + break; + case FINAL: + EnterOuterAlt(_localctx, 7); + { + State = 928; Match(FINAL); + } + break; + case STRICTFP: + EnterOuterAlt(_localctx, 8); + { + State = 929; Match(STRICTFP); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeParametersContext : ParserRuleContext { + public ITerminalNode LT() { return GetToken(Java9Parser.LT, 0); } + public TypeParameterListContext typeParameterList() { + return GetRuleContext(0); + } + public ITerminalNode GT() { return GetToken(Java9Parser.GT, 0); } + public TypeParametersContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeParameters; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeParameters(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeParameters(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeParameters(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeParametersContext typeParameters() { + TypeParametersContext _localctx = new TypeParametersContext(Context, State); + EnterRule(_localctx, 98, RULE_typeParameters); + try { + EnterOuterAlt(_localctx, 1); + { + State = 932; Match(LT); + State = 933; typeParameterList(); + State = 934; Match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeParameterListContext : ParserRuleContext { + public TypeParameterContext[] typeParameter() { + return GetRuleContexts(); + } + public TypeParameterContext typeParameter(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public TypeParameterListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeParameterList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeParameterList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeParameterList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeParameterList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeParameterListContext typeParameterList() { + TypeParameterListContext _localctx = new TypeParameterListContext(Context, State); + EnterRule(_localctx, 100, RULE_typeParameterList); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 936; typeParameter(); + State = 941; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 937; Match(COMMA); + State = 938; typeParameter(); + } + } + State = 943; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SuperclassContext : ParserRuleContext { + public ITerminalNode EXTENDS() { return GetToken(Java9Parser.EXTENDS, 0); } + public ClassTypeContext classType() { + return GetRuleContext(0); + } + public SuperclassContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_superclass; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSuperclass(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSuperclass(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSuperclass(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SuperclassContext superclass() { + SuperclassContext _localctx = new SuperclassContext(Context, State); + EnterRule(_localctx, 102, RULE_superclass); + try { + EnterOuterAlt(_localctx, 1); + { + State = 944; Match(EXTENDS); + State = 945; classType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SuperinterfacesContext : ParserRuleContext { + public ITerminalNode IMPLEMENTS() { return GetToken(Java9Parser.IMPLEMENTS, 0); } + public InterfaceTypeListContext interfaceTypeList() { + return GetRuleContext(0); + } + public SuperinterfacesContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_superinterfaces; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSuperinterfaces(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSuperinterfaces(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSuperinterfaces(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SuperinterfacesContext superinterfaces() { + SuperinterfacesContext _localctx = new SuperinterfacesContext(Context, State); + EnterRule(_localctx, 104, RULE_superinterfaces); + try { + EnterOuterAlt(_localctx, 1); + { + State = 947; Match(IMPLEMENTS); + State = 948; interfaceTypeList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InterfaceTypeListContext : ParserRuleContext { + public InterfaceTypeContext[] interfaceType() { + return GetRuleContexts(); + } + public InterfaceTypeContext interfaceType(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public InterfaceTypeListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_interfaceTypeList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInterfaceTypeList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInterfaceTypeList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInterfaceTypeList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InterfaceTypeListContext interfaceTypeList() { + InterfaceTypeListContext _localctx = new InterfaceTypeListContext(Context, State); + EnterRule(_localctx, 106, RULE_interfaceTypeList); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 950; interfaceType(); + State = 955; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 951; Match(COMMA); + State = 952; interfaceType(); + } + } + State = 957; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassBodyContext : ParserRuleContext { + public ITerminalNode LBRACE() { return GetToken(Java9Parser.LBRACE, 0); } + public ITerminalNode RBRACE() { return GetToken(Java9Parser.RBRACE, 0); } + public ClassBodyDeclarationContext[] classBodyDeclaration() { + return GetRuleContexts(); + } + public ClassBodyDeclarationContext classBodyDeclaration(int i) { + return GetRuleContext(i); + } + public ClassBodyContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classBody; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassBody(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassBody(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassBody(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassBodyContext classBody() { + ClassBodyContext _localctx = new ClassBodyContext(Context, State); + EnterRule(_localctx, 108, RULE_classBody); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 958; Match(LBRACE); + State = 962; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << MODULE) | (1L << NATIVE) | (1L << OPEN) | (1L << OPENS) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PROVIDES) | (1L << PUBLIC) | (1L << REQUIRES) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TO) | (1L << TRANSIENT) | (1L << USES) | (1L << VOID) | (1L << VOLATILE) | (1L << WITH))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (LBRACE - 70)) | (1L << (SEMI - 70)) | (1L << (AT - 70)) | (1L << (LT - 70)) | (1L << (Identifier - 70)))) != 0)) { + { + { + State = 959; classBodyDeclaration(); + } + } + State = 964; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 965; Match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassBodyDeclarationContext : ParserRuleContext { + public ClassMemberDeclarationContext classMemberDeclaration() { + return GetRuleContext(0); + } + public InstanceInitializerContext instanceInitializer() { + return GetRuleContext(0); + } + public StaticInitializerContext staticInitializer() { + return GetRuleContext(0); + } + public ConstructorDeclarationContext constructorDeclaration() { + return GetRuleContext(0); + } + public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classBodyDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassBodyDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassBodyDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassBodyDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassBodyDeclarationContext classBodyDeclaration() { + ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(Context, State); + EnterRule(_localctx, 110, RULE_classBodyDeclaration); + try { + State = 971; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 967; classMemberDeclaration(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 968; instanceInitializer(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 969; staticInitializer(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 970; constructorDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassMemberDeclarationContext : ParserRuleContext { + public FieldDeclarationContext fieldDeclaration() { + return GetRuleContext(0); + } + public MethodDeclarationContext methodDeclaration() { + return GetRuleContext(0); + } + public ClassDeclarationContext classDeclaration() { + return GetRuleContext(0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classMemberDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassMemberDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassMemberDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassMemberDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassMemberDeclarationContext classMemberDeclaration() { + ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(Context, State); + EnterRule(_localctx, 112, RULE_classMemberDeclaration); + try { + State = 978; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,65,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 973; fieldDeclaration(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 974; methodDeclaration(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 975; classDeclaration(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 976; interfaceDeclaration(); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 977; Match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class FieldDeclarationContext : ParserRuleContext { + public UnannTypeContext unannType() { + return GetRuleContext(0); + } + public VariableDeclaratorListContext variableDeclaratorList() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public FieldModifierContext[] fieldModifier() { + return GetRuleContexts(); + } + public FieldModifierContext fieldModifier(int i) { + return GetRuleContext(i); + } + public FieldDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_fieldDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterFieldDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitFieldDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitFieldDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public FieldDeclarationContext fieldDeclaration() { + FieldDeclarationContext _localctx = new FieldDeclarationContext(Context, State); + EnterRule(_localctx, 114, RULE_fieldDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 983; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (((((_la - 19)) & ~0x3f) == 0 && ((1L << (_la - 19)) & ((1L << (FINAL - 19)) | (1L << (PRIVATE - 19)) | (1L << (PROTECTED - 19)) | (1L << (PUBLIC - 19)) | (1L << (STATIC - 19)) | (1L << (TRANSIENT - 19)) | (1L << (VOLATILE - 19)) | (1L << (AT - 19)))) != 0)) { + { + { + State = 980; fieldModifier(); + } + } + State = 985; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 986; unannType(); + State = 987; variableDeclaratorList(); + State = 988; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class FieldModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public ITerminalNode PUBLIC() { return GetToken(Java9Parser.PUBLIC, 0); } + public ITerminalNode PROTECTED() { return GetToken(Java9Parser.PROTECTED, 0); } + public ITerminalNode PRIVATE() { return GetToken(Java9Parser.PRIVATE, 0); } + public ITerminalNode STATIC() { return GetToken(Java9Parser.STATIC, 0); } + public ITerminalNode FINAL() { return GetToken(Java9Parser.FINAL, 0); } + public ITerminalNode TRANSIENT() { return GetToken(Java9Parser.TRANSIENT, 0); } + public ITerminalNode VOLATILE() { return GetToken(Java9Parser.VOLATILE, 0); } + public FieldModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_fieldModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterFieldModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitFieldModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitFieldModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public FieldModifierContext fieldModifier() { + FieldModifierContext _localctx = new FieldModifierContext(Context, State); + EnterRule(_localctx, 116, RULE_fieldModifier); + try { + State = 998; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case AT: + EnterOuterAlt(_localctx, 1); + { + State = 990; annotation(); + } + break; + case PUBLIC: + EnterOuterAlt(_localctx, 2); + { + State = 991; Match(PUBLIC); + } + break; + case PROTECTED: + EnterOuterAlt(_localctx, 3); + { + State = 992; Match(PROTECTED); + } + break; + case PRIVATE: + EnterOuterAlt(_localctx, 4); + { + State = 993; Match(PRIVATE); + } + break; + case STATIC: + EnterOuterAlt(_localctx, 5); + { + State = 994; Match(STATIC); + } + break; + case FINAL: + EnterOuterAlt(_localctx, 6); + { + State = 995; Match(FINAL); + } + break; + case TRANSIENT: + EnterOuterAlt(_localctx, 7); + { + State = 996; Match(TRANSIENT); + } + break; + case VOLATILE: + EnterOuterAlt(_localctx, 8); + { + State = 997; Match(VOLATILE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class VariableDeclaratorListContext : ParserRuleContext { + public VariableDeclaratorContext[] variableDeclarator() { + return GetRuleContexts(); + } + public VariableDeclaratorContext variableDeclarator(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public VariableDeclaratorListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_variableDeclaratorList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterVariableDeclaratorList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitVariableDeclaratorList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitVariableDeclaratorList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public VariableDeclaratorListContext variableDeclaratorList() { + VariableDeclaratorListContext _localctx = new VariableDeclaratorListContext(Context, State); + EnterRule(_localctx, 118, RULE_variableDeclaratorList); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1000; variableDeclarator(); + State = 1005; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 1001; Match(COMMA); + State = 1002; variableDeclarator(); + } + } + State = 1007; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class VariableDeclaratorContext : ParserRuleContext { + public VariableDeclaratorIdContext variableDeclaratorId() { + return GetRuleContext(0); + } + public ITerminalNode ASSIGN() { return GetToken(Java9Parser.ASSIGN, 0); } + public VariableInitializerContext variableInitializer() { + return GetRuleContext(0); + } + public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_variableDeclarator; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterVariableDeclarator(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitVariableDeclarator(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitVariableDeclarator(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public VariableDeclaratorContext variableDeclarator() { + VariableDeclaratorContext _localctx = new VariableDeclaratorContext(Context, State); + EnterRule(_localctx, 120, RULE_variableDeclarator); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1008; variableDeclaratorId(); + State = 1011; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==ASSIGN) { + { + State = 1009; Match(ASSIGN); + State = 1010; variableInitializer(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class VariableDeclaratorIdContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public DimsContext dims() { + return GetRuleContext(0); + } + public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_variableDeclaratorId; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterVariableDeclaratorId(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitVariableDeclaratorId(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitVariableDeclaratorId(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public VariableDeclaratorIdContext variableDeclaratorId() { + VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(Context, State); + EnterRule(_localctx, 122, RULE_variableDeclaratorId); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1013; identifier(); + State = 1015; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LBRACK || _la==AT) { + { + State = 1014; dims(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class VariableInitializerContext : ParserRuleContext { + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ArrayInitializerContext arrayInitializer() { + return GetRuleContext(0); + } + public VariableInitializerContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_variableInitializer; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterVariableInitializer(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitVariableInitializer(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitVariableInitializer(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public VariableInitializerContext variableInitializer() { + VariableInitializerContext _localctx = new VariableInitializerContext(Context, State); + EnterRule(_localctx, 124, RULE_variableInitializer); + try { + State = 1019; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case EXPORTS: + case FLOAT: + case INT: + case LONG: + case MODULE: + case NEW: + case OPEN: + case OPENS: + case PROVIDES: + case REQUIRES: + case SHORT: + case SUPER: + case THIS: + case TO: + case USES: + case VOID: + case WITH: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INC: + case DEC: + case ADD: + case SUB: + case Identifier: + EnterOuterAlt(_localctx, 1); + { + State = 1017; expression(); + } + break; + case LBRACE: + EnterOuterAlt(_localctx, 2); + { + State = 1018; arrayInitializer(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannTypeContext : ParserRuleContext { + public UnannPrimitiveTypeContext unannPrimitiveType() { + return GetRuleContext(0); + } + public UnannReferenceTypeContext unannReferenceType() { + return GetRuleContext(0); + } + public UnannTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannTypeContext unannType() { + UnannTypeContext _localctx = new UnannTypeContext(Context, State); + EnterRule(_localctx, 126, RULE_unannType); + try { + State = 1023; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,72,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1021; unannPrimitiveType(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1022; unannReferenceType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannPrimitiveTypeContext : ParserRuleContext { + public NumericTypeContext numericType() { + return GetRuleContext(0); + } + public ITerminalNode BOOLEAN() { return GetToken(Java9Parser.BOOLEAN, 0); } + public UnannPrimitiveTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannPrimitiveType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannPrimitiveType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannPrimitiveType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannPrimitiveType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannPrimitiveTypeContext unannPrimitiveType() { + UnannPrimitiveTypeContext _localctx = new UnannPrimitiveTypeContext(Context, State); + EnterRule(_localctx, 128, RULE_unannPrimitiveType); + try { + State = 1027; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + EnterOuterAlt(_localctx, 1); + { + State = 1025; numericType(); + } + break; + case BOOLEAN: + EnterOuterAlt(_localctx, 2); + { + State = 1026; Match(BOOLEAN); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannReferenceTypeContext : ParserRuleContext { + public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { + return GetRuleContext(0); + } + public UnannTypeVariableContext unannTypeVariable() { + return GetRuleContext(0); + } + public UnannArrayTypeContext unannArrayType() { + return GetRuleContext(0); + } + public UnannReferenceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannReferenceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannReferenceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannReferenceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannReferenceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannReferenceTypeContext unannReferenceType() { + UnannReferenceTypeContext _localctx = new UnannReferenceTypeContext(Context, State); + EnterRule(_localctx, 130, RULE_unannReferenceType); + try { + State = 1032; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,74,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1029; unannClassOrInterfaceType(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1030; unannTypeVariable(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1031; unannArrayType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannClassOrInterfaceTypeContext : ParserRuleContext { + public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() { + return GetRuleContext(0); + } + public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() { + return GetRuleContext(0); + } + public UnannClassType_lf_unannClassOrInterfaceTypeContext[] unannClassType_lf_unannClassOrInterfaceType() { + return GetRuleContexts(); + } + public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType(int i) { + return GetRuleContext(i); + } + public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext[] unannInterfaceType_lf_unannClassOrInterfaceType() { + return GetRuleContexts(); + } + public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType(int i) { + return GetRuleContext(i); + } + public UnannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannClassOrInterfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannClassOrInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannClassOrInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannClassOrInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { + UnannClassOrInterfaceTypeContext _localctx = new UnannClassOrInterfaceTypeContext(Context, State); + EnterRule(_localctx, 132, RULE_unannClassOrInterfaceType); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 1036; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,75,Context) ) { + case 1: + { + State = 1034; unannClassType_lfno_unannClassOrInterfaceType(); + } + break; + case 2: + { + State = 1035; unannInterfaceType_lfno_unannClassOrInterfaceType(); + } + break; + } + State = 1042; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,77,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + State = 1040; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { + case 1: + { + State = 1038; unannClassType_lf_unannClassOrInterfaceType(); + } + break; + case 2: + { + State = 1039; unannInterfaceType_lf_unannClassOrInterfaceType(); + } + break; + } + } + } + State = 1044; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,77,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannClassTypeContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public UnannClassTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannClassType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannClassType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannClassType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannClassType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannClassTypeContext unannClassType() { + UnannClassTypeContext _localctx = new UnannClassTypeContext(Context, State); + EnterRule(_localctx, 134, RULE_unannClassType); + int _la; + try { + State = 1061; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,81,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1045; identifier(); + State = 1047; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 1046; typeArguments(); + } + } + + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1049; unannClassOrInterfaceType(); + State = 1050; Match(DOT); + State = 1054; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 1051; annotation(); + } + } + State = 1056; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1057; identifier(); + State = 1059; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 1058; typeArguments(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannClassType_lf_unannClassOrInterfaceTypeContext : ParserRuleContext { + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public UnannClassType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannClassType_lf_unannClassOrInterfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannClassType_lf_unannClassOrInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannClassType_lf_unannClassOrInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannClassType_lf_unannClassOrInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() { + UnannClassType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lf_unannClassOrInterfaceTypeContext(Context, State); + EnterRule(_localctx, 136, RULE_unannClassType_lf_unannClassOrInterfaceType); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1063; Match(DOT); + State = 1067; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 1064; annotation(); + } + } + State = 1069; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1070; identifier(); + State = 1072; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 1071; typeArguments(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannClassType_lfno_unannClassOrInterfaceTypeContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public UnannClassType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannClassType_lfno_unannClassOrInterfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannClassType_lfno_unannClassOrInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannClassType_lfno_unannClassOrInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannClassType_lfno_unannClassOrInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() { + UnannClassType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lfno_unannClassOrInterfaceTypeContext(Context, State); + EnterRule(_localctx, 138, RULE_unannClassType_lfno_unannClassOrInterfaceType); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1074; identifier(); + State = 1076; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 1075; typeArguments(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannInterfaceTypeContext : ParserRuleContext { + public UnannClassTypeContext unannClassType() { + return GetRuleContext(0); + } + public UnannInterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannInterfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannInterfaceTypeContext unannInterfaceType() { + UnannInterfaceTypeContext _localctx = new UnannInterfaceTypeContext(Context, State); + EnterRule(_localctx, 140, RULE_unannInterfaceType); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1078; unannClassType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannInterfaceType_lf_unannClassOrInterfaceTypeContext : ParserRuleContext { + public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() { + return GetRuleContext(0); + } + public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannInterfaceType_lf_unannClassOrInterfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannInterfaceType_lf_unannClassOrInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannInterfaceType_lf_unannClassOrInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannInterfaceType_lf_unannClassOrInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType() { + UnannInterfaceType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(Context, State); + EnterRule(_localctx, 142, RULE_unannInterfaceType_lf_unannClassOrInterfaceType); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1080; unannClassType_lf_unannClassOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext : ParserRuleContext { + public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() { + return GetRuleContext(0); + } + public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannInterfaceType_lfno_unannClassOrInterfaceType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannInterfaceType_lfno_unannClassOrInterfaceType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannInterfaceType_lfno_unannClassOrInterfaceType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannInterfaceType_lfno_unannClassOrInterfaceType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() { + UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(Context, State); + EnterRule(_localctx, 144, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1082; unannClassType_lfno_unannClassOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannTypeVariableContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public UnannTypeVariableContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannTypeVariable; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannTypeVariable(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannTypeVariable(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannTypeVariable(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannTypeVariableContext unannTypeVariable() { + UnannTypeVariableContext _localctx = new UnannTypeVariableContext(Context, State); + EnterRule(_localctx, 146, RULE_unannTypeVariable); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1084; identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnannArrayTypeContext : ParserRuleContext { + public UnannPrimitiveTypeContext unannPrimitiveType() { + return GetRuleContext(0); + } + public DimsContext dims() { + return GetRuleContext(0); + } + public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { + return GetRuleContext(0); + } + public UnannTypeVariableContext unannTypeVariable() { + return GetRuleContext(0); + } + public UnannArrayTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unannArrayType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnannArrayType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnannArrayType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnannArrayType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnannArrayTypeContext unannArrayType() { + UnannArrayTypeContext _localctx = new UnannArrayTypeContext(Context, State); + EnterRule(_localctx, 148, RULE_unannArrayType); + try { + State = 1095; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,85,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1086; unannPrimitiveType(); + State = 1087; dims(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1089; unannClassOrInterfaceType(); + State = 1090; dims(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1092; unannTypeVariable(); + State = 1093; dims(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodDeclarationContext : ParserRuleContext { + public MethodHeaderContext methodHeader() { + return GetRuleContext(0); + } + public MethodBodyContext methodBody() { + return GetRuleContext(0); + } + public MethodModifierContext[] methodModifier() { + return GetRuleContexts(); + } + public MethodModifierContext methodModifier(int i) { + return GetRuleContext(i); + } + public MethodDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodDeclarationContext methodDeclaration() { + MethodDeclarationContext _localctx = new MethodDeclarationContext(Context, State); + EnterRule(_localctx, 150, RULE_methodDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1100; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED))) != 0) || _la==AT) { + { + { + State = 1097; methodModifier(); + } + } + State = 1102; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1103; methodHeader(); + State = 1104; methodBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public ITerminalNode PUBLIC() { return GetToken(Java9Parser.PUBLIC, 0); } + public ITerminalNode PROTECTED() { return GetToken(Java9Parser.PROTECTED, 0); } + public ITerminalNode PRIVATE() { return GetToken(Java9Parser.PRIVATE, 0); } + public ITerminalNode ABSTRACT() { return GetToken(Java9Parser.ABSTRACT, 0); } + public ITerminalNode STATIC() { return GetToken(Java9Parser.STATIC, 0); } + public ITerminalNode FINAL() { return GetToken(Java9Parser.FINAL, 0); } + public ITerminalNode SYNCHRONIZED() { return GetToken(Java9Parser.SYNCHRONIZED, 0); } + public ITerminalNode NATIVE() { return GetToken(Java9Parser.NATIVE, 0); } + public ITerminalNode STRICTFP() { return GetToken(Java9Parser.STRICTFP, 0); } + public MethodModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodModifierContext methodModifier() { + MethodModifierContext _localctx = new MethodModifierContext(Context, State); + EnterRule(_localctx, 152, RULE_methodModifier); + try { + State = 1116; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case AT: + EnterOuterAlt(_localctx, 1); + { + State = 1106; annotation(); + } + break; + case PUBLIC: + EnterOuterAlt(_localctx, 2); + { + State = 1107; Match(PUBLIC); + } + break; + case PROTECTED: + EnterOuterAlt(_localctx, 3); + { + State = 1108; Match(PROTECTED); + } + break; + case PRIVATE: + EnterOuterAlt(_localctx, 4); + { + State = 1109; Match(PRIVATE); + } + break; + case ABSTRACT: + EnterOuterAlt(_localctx, 5); + { + State = 1110; Match(ABSTRACT); + } + break; + case STATIC: + EnterOuterAlt(_localctx, 6); + { + State = 1111; Match(STATIC); + } + break; + case FINAL: + EnterOuterAlt(_localctx, 7); + { + State = 1112; Match(FINAL); + } + break; + case SYNCHRONIZED: + EnterOuterAlt(_localctx, 8); + { + State = 1113; Match(SYNCHRONIZED); + } + break; + case NATIVE: + EnterOuterAlt(_localctx, 9); + { + State = 1114; Match(NATIVE); + } + break; + case STRICTFP: + EnterOuterAlt(_localctx, 10); + { + State = 1115; Match(STRICTFP); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodHeaderContext : ParserRuleContext { + public ResultContext result() { + return GetRuleContext(0); + } + public MethodDeclaratorContext methodDeclarator() { + return GetRuleContext(0); + } + public Throws_Context throws_() { + return GetRuleContext(0); + } + public TypeParametersContext typeParameters() { + return GetRuleContext(0); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public MethodHeaderContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodHeader; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodHeader(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodHeader(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodHeader(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodHeaderContext methodHeader() { + MethodHeaderContext _localctx = new MethodHeaderContext(Context, State); + EnterRule(_localctx, 154, RULE_methodHeader); + int _la; + try { + State = 1135; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case EXPORTS: + case FLOAT: + case INT: + case LONG: + case MODULE: + case OPEN: + case OPENS: + case PROVIDES: + case REQUIRES: + case SHORT: + case TO: + case USES: + case VOID: + case WITH: + case Identifier: + EnterOuterAlt(_localctx, 1); + { + State = 1118; result(); + State = 1119; methodDeclarator(); + State = 1121; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==THROWS) { + { + State = 1120; throws_(); + } + } + + } + break; + case LT: + EnterOuterAlt(_localctx, 2); + { + State = 1123; typeParameters(); + State = 1127; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 1124; annotation(); + } + } + State = 1129; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1130; result(); + State = 1131; methodDeclarator(); + State = 1133; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==THROWS) { + { + State = 1132; throws_(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ResultContext : ParserRuleContext { + public UnannTypeContext unannType() { + return GetRuleContext(0); + } + public ITerminalNode VOID() { return GetToken(Java9Parser.VOID, 0); } + public ResultContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_result; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterResult(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitResult(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitResult(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ResultContext result() { + ResultContext _localctx = new ResultContext(Context, State); + EnterRule(_localctx, 156, RULE_result); + try { + State = 1139; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case EXPORTS: + case FLOAT: + case INT: + case LONG: + case MODULE: + case OPEN: + case OPENS: + case PROVIDES: + case REQUIRES: + case SHORT: + case TO: + case USES: + case WITH: + case Identifier: + EnterOuterAlt(_localctx, 1); + { + State = 1137; unannType(); + } + break; + case VOID: + EnterOuterAlt(_localctx, 2); + { + State = 1138; Match(VOID); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodDeclaratorContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public FormalParameterListContext formalParameterList() { + return GetRuleContext(0); + } + public DimsContext dims() { + return GetRuleContext(0); + } + public MethodDeclaratorContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodDeclarator; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodDeclarator(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodDeclarator(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodDeclarator(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodDeclaratorContext methodDeclarator() { + MethodDeclaratorContext _localctx = new MethodDeclaratorContext(Context, State); + EnterRule(_localctx, 158, RULE_methodDeclarator); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1141; identifier(); + State = 1142; Match(LPAREN); + State = 1144; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << TO) | (1L << USES) | (1L << WITH))) != 0) || _la==AT || _la==Identifier) { + { + State = 1143; formalParameterList(); + } + } + + State = 1146; Match(RPAREN); + State = 1148; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LBRACK || _la==AT) { + { + State = 1147; dims(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class FormalParameterListContext : ParserRuleContext { + public FormalParametersContext formalParameters() { + return GetRuleContext(0); + } + public ITerminalNode COMMA() { return GetToken(Java9Parser.COMMA, 0); } + public LastFormalParameterContext lastFormalParameter() { + return GetRuleContext(0); + } + public ReceiverParameterContext receiverParameter() { + return GetRuleContext(0); + } + public FormalParameterListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_formalParameterList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterFormalParameterList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitFormalParameterList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitFormalParameterList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public FormalParameterListContext formalParameterList() { + FormalParameterListContext _localctx = new FormalParameterListContext(Context, State); + EnterRule(_localctx, 160, RULE_formalParameterList); + try { + State = 1156; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,95,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1150; formalParameters(); + State = 1151; Match(COMMA); + State = 1152; lastFormalParameter(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1154; lastFormalParameter(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1155; receiverParameter(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class FormalParametersContext : ParserRuleContext { + public FormalParameterContext[] formalParameter() { + return GetRuleContexts(); + } + public FormalParameterContext formalParameter(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public ReceiverParameterContext receiverParameter() { + return GetRuleContext(0); + } + public FormalParametersContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_formalParameters; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterFormalParameters(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitFormalParameters(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitFormalParameters(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public FormalParametersContext formalParameters() { + FormalParametersContext _localctx = new FormalParametersContext(Context, State); + EnterRule(_localctx, 162, RULE_formalParameters); + try { + int _alt; + State = 1174; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,98,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1158; formalParameter(); + State = 1163; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,96,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 1159; Match(COMMA); + State = 1160; formalParameter(); + } + } + } + State = 1165; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,96,Context); + } + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1166; receiverParameter(); + State = 1171; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,97,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 1167; Match(COMMA); + State = 1168; formalParameter(); + } + } + } + State = 1173; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,97,Context); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class FormalParameterContext : ParserRuleContext { + public UnannTypeContext unannType() { + return GetRuleContext(0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return GetRuleContext(0); + } + public VariableModifierContext[] variableModifier() { + return GetRuleContexts(); + } + public VariableModifierContext variableModifier(int i) { + return GetRuleContext(i); + } + public FormalParameterContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_formalParameter; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterFormalParameter(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitFormalParameter(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitFormalParameter(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public FormalParameterContext formalParameter() { + FormalParameterContext _localctx = new FormalParameterContext(Context, State); + EnterRule(_localctx, 164, RULE_formalParameter); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1179; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==FINAL || _la==AT) { + { + { + State = 1176; variableModifier(); + } + } + State = 1181; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1182; unannType(); + State = 1183; variableDeclaratorId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class VariableModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public ITerminalNode FINAL() { return GetToken(Java9Parser.FINAL, 0); } + public VariableModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_variableModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterVariableModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitVariableModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitVariableModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public VariableModifierContext variableModifier() { + VariableModifierContext _localctx = new VariableModifierContext(Context, State); + EnterRule(_localctx, 166, RULE_variableModifier); + try { + State = 1187; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case AT: + EnterOuterAlt(_localctx, 1); + { + State = 1185; annotation(); + } + break; + case FINAL: + EnterOuterAlt(_localctx, 2); + { + State = 1186; Match(FINAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class LastFormalParameterContext : ParserRuleContext { + public UnannTypeContext unannType() { + return GetRuleContext(0); + } + public ITerminalNode ELLIPSIS() { return GetToken(Java9Parser.ELLIPSIS, 0); } + public VariableDeclaratorIdContext variableDeclaratorId() { + return GetRuleContext(0); + } + public VariableModifierContext[] variableModifier() { + return GetRuleContexts(); + } + public VariableModifierContext variableModifier(int i) { + return GetRuleContext(i); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public FormalParameterContext formalParameter() { + return GetRuleContext(0); + } + public LastFormalParameterContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_lastFormalParameter; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterLastFormalParameter(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitLastFormalParameter(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitLastFormalParameter(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public LastFormalParameterContext lastFormalParameter() { + LastFormalParameterContext _localctx = new LastFormalParameterContext(Context, State); + EnterRule(_localctx, 168, RULE_lastFormalParameter); + int _la; + try { + State = 1206; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,103,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1192; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==FINAL || _la==AT) { + { + { + State = 1189; variableModifier(); + } + } + State = 1194; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1195; unannType(); + State = 1199; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 1196; annotation(); + } + } + State = 1201; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1202; Match(ELLIPSIS); + State = 1203; variableDeclaratorId(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1205; formalParameter(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ReceiverParameterContext : ParserRuleContext { + public UnannTypeContext unannType() { + return GetRuleContext(0); + } + public ITerminalNode THIS() { return GetToken(Java9Parser.THIS, 0); } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ReceiverParameterContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_receiverParameter; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterReceiverParameter(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitReceiverParameter(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitReceiverParameter(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ReceiverParameterContext receiverParameter() { + ReceiverParameterContext _localctx = new ReceiverParameterContext(Context, State); + EnterRule(_localctx, 170, RULE_receiverParameter); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1211; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 1208; annotation(); + } + } + State = 1213; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1214; unannType(); + State = 1218; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXPORTS) | (1L << MODULE) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << TO) | (1L << USES) | (1L << WITH))) != 0) || _la==Identifier) { + { + State = 1215; identifier(); + State = 1216; Match(DOT); + } + } + + State = 1220; Match(THIS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class Throws_Context : ParserRuleContext { + public ITerminalNode THROWS() { return GetToken(Java9Parser.THROWS, 0); } + public ExceptionTypeListContext exceptionTypeList() { + return GetRuleContext(0); + } + public Throws_Context(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_throws_; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterThrows_(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitThrows_(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitThrows_(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public Throws_Context throws_() { + Throws_Context _localctx = new Throws_Context(Context, State); + EnterRule(_localctx, 172, RULE_throws_); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1222; Match(THROWS); + State = 1223; exceptionTypeList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ExceptionTypeListContext : ParserRuleContext { + public ExceptionTypeContext[] exceptionType() { + return GetRuleContexts(); + } + public ExceptionTypeContext exceptionType(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public ExceptionTypeListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_exceptionTypeList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterExceptionTypeList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitExceptionTypeList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitExceptionTypeList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ExceptionTypeListContext exceptionTypeList() { + ExceptionTypeListContext _localctx = new ExceptionTypeListContext(Context, State); + EnterRule(_localctx, 174, RULE_exceptionTypeList); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1225; exceptionType(); + State = 1230; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 1226; Match(COMMA); + State = 1227; exceptionType(); + } + } + State = 1232; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ExceptionTypeContext : ParserRuleContext { + public ClassTypeContext classType() { + return GetRuleContext(0); + } + public TypeVariableContext typeVariable() { + return GetRuleContext(0); + } + public ExceptionTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_exceptionType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterExceptionType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitExceptionType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitExceptionType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ExceptionTypeContext exceptionType() { + ExceptionTypeContext _localctx = new ExceptionTypeContext(Context, State); + EnterRule(_localctx, 176, RULE_exceptionType); + try { + State = 1235; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,107,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1233; classType(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1234; typeVariable(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodBodyContext : ParserRuleContext { + public BlockContext block() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public MethodBodyContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodBody; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodBody(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodBody(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodBody(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodBodyContext methodBody() { + MethodBodyContext _localctx = new MethodBodyContext(Context, State); + EnterRule(_localctx, 178, RULE_methodBody); + try { + State = 1239; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case LBRACE: + EnterOuterAlt(_localctx, 1); + { + State = 1237; block(); + } + break; + case SEMI: + EnterOuterAlt(_localctx, 2); + { + State = 1238; Match(SEMI); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InstanceInitializerContext : ParserRuleContext { + public BlockContext block() { + return GetRuleContext(0); + } + public InstanceInitializerContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_instanceInitializer; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInstanceInitializer(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInstanceInitializer(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInstanceInitializer(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InstanceInitializerContext instanceInitializer() { + InstanceInitializerContext _localctx = new InstanceInitializerContext(Context, State); + EnterRule(_localctx, 180, RULE_instanceInitializer); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1241; block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class StaticInitializerContext : ParserRuleContext { + public ITerminalNode STATIC() { return GetToken(Java9Parser.STATIC, 0); } + public BlockContext block() { + return GetRuleContext(0); + } + public StaticInitializerContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_staticInitializer; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterStaticInitializer(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitStaticInitializer(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitStaticInitializer(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public StaticInitializerContext staticInitializer() { + StaticInitializerContext _localctx = new StaticInitializerContext(Context, State); + EnterRule(_localctx, 182, RULE_staticInitializer); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1243; Match(STATIC); + State = 1244; block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ConstructorDeclarationContext : ParserRuleContext { + public ConstructorDeclaratorContext constructorDeclarator() { + return GetRuleContext(0); + } + public ConstructorBodyContext constructorBody() { + return GetRuleContext(0); + } + public ConstructorModifierContext[] constructorModifier() { + return GetRuleContexts(); + } + public ConstructorModifierContext constructorModifier(int i) { + return GetRuleContext(i); + } + public Throws_Context throws_() { + return GetRuleContext(0); + } + public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_constructorDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterConstructorDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitConstructorDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitConstructorDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ConstructorDeclarationContext constructorDeclaration() { + ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(Context, State); + EnterRule(_localctx, 184, RULE_constructorDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1249; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (((((_la - 37)) & ~0x3f) == 0 && ((1L << (_la - 37)) & ((1L << (PRIVATE - 37)) | (1L << (PROTECTED - 37)) | (1L << (PUBLIC - 37)) | (1L << (AT - 37)))) != 0)) { + { + { + State = 1246; constructorModifier(); + } + } + State = 1251; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1252; constructorDeclarator(); + State = 1254; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==THROWS) { + { + State = 1253; throws_(); + } + } + + State = 1256; constructorBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ConstructorModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public ITerminalNode PUBLIC() { return GetToken(Java9Parser.PUBLIC, 0); } + public ITerminalNode PROTECTED() { return GetToken(Java9Parser.PROTECTED, 0); } + public ITerminalNode PRIVATE() { return GetToken(Java9Parser.PRIVATE, 0); } + public ConstructorModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_constructorModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterConstructorModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitConstructorModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitConstructorModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ConstructorModifierContext constructorModifier() { + ConstructorModifierContext _localctx = new ConstructorModifierContext(Context, State); + EnterRule(_localctx, 186, RULE_constructorModifier); + try { + State = 1262; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case AT: + EnterOuterAlt(_localctx, 1); + { + State = 1258; annotation(); + } + break; + case PUBLIC: + EnterOuterAlt(_localctx, 2); + { + State = 1259; Match(PUBLIC); + } + break; + case PROTECTED: + EnterOuterAlt(_localctx, 3); + { + State = 1260; Match(PROTECTED); + } + break; + case PRIVATE: + EnterOuterAlt(_localctx, 4); + { + State = 1261; Match(PRIVATE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ConstructorDeclaratorContext : ParserRuleContext { + public SimpleTypeNameContext simpleTypeName() { + return GetRuleContext(0); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public TypeParametersContext typeParameters() { + return GetRuleContext(0); + } + public FormalParameterListContext formalParameterList() { + return GetRuleContext(0); + } + public ConstructorDeclaratorContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_constructorDeclarator; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterConstructorDeclarator(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitConstructorDeclarator(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitConstructorDeclarator(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ConstructorDeclaratorContext constructorDeclarator() { + ConstructorDeclaratorContext _localctx = new ConstructorDeclaratorContext(Context, State); + EnterRule(_localctx, 188, RULE_constructorDeclarator); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1265; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 1264; typeParameters(); + } + } + + State = 1267; simpleTypeName(); + State = 1268; Match(LPAREN); + State = 1270; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << TO) | (1L << USES) | (1L << WITH))) != 0) || _la==AT || _la==Identifier) { + { + State = 1269; formalParameterList(); + } + } + + State = 1272; Match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SimpleTypeNameContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public SimpleTypeNameContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_simpleTypeName; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSimpleTypeName(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSimpleTypeName(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSimpleTypeName(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SimpleTypeNameContext simpleTypeName() { + SimpleTypeNameContext _localctx = new SimpleTypeNameContext(Context, State); + EnterRule(_localctx, 190, RULE_simpleTypeName); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1274; identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ConstructorBodyContext : ParserRuleContext { + public ITerminalNode LBRACE() { return GetToken(Java9Parser.LBRACE, 0); } + public ITerminalNode RBRACE() { return GetToken(Java9Parser.RBRACE, 0); } + public ExplicitConstructorInvocationContext explicitConstructorInvocation() { + return GetRuleContext(0); + } + public BlockStatementsContext blockStatements() { + return GetRuleContext(0); + } + public ConstructorBodyContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_constructorBody; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterConstructorBody(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitConstructorBody(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitConstructorBody(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ConstructorBodyContext constructorBody() { + ConstructorBodyContext _localctx = new ConstructorBodyContext(Context, State); + EnterRule(_localctx, 192, RULE_constructorBody); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1276; Match(LBRACE); + State = 1278; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,114,Context) ) { + case 1: + { + State = 1277; explicitConstructorInvocation(); + } + break; + } + State = 1281; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PROVIDES) | (1L << PUBLIC) | (1L << REQUIRES) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L << SYNCHRONIZED) | (1L << THIS) | (1L << THROW) | (1L << TO) | (1L << TRY) | (1L << USES) | (1L << VOID) | (1L << WHILE) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (AT - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1280; blockStatements(); + } + } + + State = 1283; Match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ExplicitConstructorInvocationContext : ParserRuleContext { + public ITerminalNode THIS() { return GetToken(Java9Parser.THIS, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public ArgumentListContext argumentList() { + return GetRuleContext(0); + } + public ITerminalNode SUPER() { return GetToken(Java9Parser.SUPER, 0); } + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public PrimaryContext primary() { + return GetRuleContext(0); + } + public ExplicitConstructorInvocationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_explicitConstructorInvocation; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterExplicitConstructorInvocation(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitExplicitConstructorInvocation(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitExplicitConstructorInvocation(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ExplicitConstructorInvocationContext explicitConstructorInvocation() { + ExplicitConstructorInvocationContext _localctx = new ExplicitConstructorInvocationContext(Context, State); + EnterRule(_localctx, 194, RULE_explicitConstructorInvocation); + int _la; + try { + State = 1331; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,124,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1286; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 1285; typeArguments(); + } + } + + State = 1288; Match(THIS); + State = 1289; Match(LPAREN); + State = 1291; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1290; argumentList(); + } + } + + State = 1293; Match(RPAREN); + State = 1294; Match(SEMI); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1296; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 1295; typeArguments(); + } + } + + State = 1298; Match(SUPER); + State = 1299; Match(LPAREN); + State = 1301; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1300; argumentList(); + } + } + + State = 1303; Match(RPAREN); + State = 1304; Match(SEMI); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1305; expressionName(); + State = 1306; Match(DOT); + State = 1308; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 1307; typeArguments(); + } + } + + State = 1310; Match(SUPER); + State = 1311; Match(LPAREN); + State = 1313; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1312; argumentList(); + } + } + + State = 1315; Match(RPAREN); + State = 1316; Match(SEMI); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 1318; primary(); + State = 1319; Match(DOT); + State = 1321; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 1320; typeArguments(); + } + } + + State = 1323; Match(SUPER); + State = 1324; Match(LPAREN); + State = 1326; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1325; argumentList(); + } + } + + State = 1328; Match(RPAREN); + State = 1329; Match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class EnumDeclarationContext : ParserRuleContext { + public ITerminalNode ENUM() { return GetToken(Java9Parser.ENUM, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public EnumBodyContext enumBody() { + return GetRuleContext(0); + } + public ClassModifierContext[] classModifier() { + return GetRuleContexts(); + } + public ClassModifierContext classModifier(int i) { + return GetRuleContext(i); + } + public SuperinterfacesContext superinterfaces() { + return GetRuleContext(0); + } + public EnumDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_enumDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterEnumDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitEnumDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitEnumDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public EnumDeclarationContext enumDeclaration() { + EnumDeclarationContext _localctx = new EnumDeclarationContext(Context, State); + EnterRule(_localctx, 196, RULE_enumDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1336; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + State = 1333; classModifier(); + } + } + State = 1338; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1339; Match(ENUM); + State = 1340; identifier(); + State = 1342; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==IMPLEMENTS) { + { + State = 1341; superinterfaces(); + } + } + + State = 1344; enumBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class EnumBodyContext : ParserRuleContext { + public ITerminalNode LBRACE() { return GetToken(Java9Parser.LBRACE, 0); } + public ITerminalNode RBRACE() { return GetToken(Java9Parser.RBRACE, 0); } + public EnumConstantListContext enumConstantList() { + return GetRuleContext(0); + } + public ITerminalNode COMMA() { return GetToken(Java9Parser.COMMA, 0); } + public EnumBodyDeclarationsContext enumBodyDeclarations() { + return GetRuleContext(0); + } + public EnumBodyContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_enumBody; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterEnumBody(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitEnumBody(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitEnumBody(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public EnumBodyContext enumBody() { + EnumBodyContext _localctx = new EnumBodyContext(Context, State); + EnterRule(_localctx, 198, RULE_enumBody); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1346; Match(LBRACE); + State = 1348; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXPORTS) | (1L << MODULE) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << TO) | (1L << USES) | (1L << WITH))) != 0) || _la==AT || _la==Identifier) { + { + State = 1347; enumConstantList(); + } + } + + State = 1351; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==COMMA) { + { + State = 1350; Match(COMMA); + } + } + + State = 1354; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==SEMI) { + { + State = 1353; enumBodyDeclarations(); + } + } + + State = 1356; Match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class EnumConstantListContext : ParserRuleContext { + public EnumConstantContext[] enumConstant() { + return GetRuleContexts(); + } + public EnumConstantContext enumConstant(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public EnumConstantListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_enumConstantList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterEnumConstantList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitEnumConstantList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitEnumConstantList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public EnumConstantListContext enumConstantList() { + EnumConstantListContext _localctx = new EnumConstantListContext(Context, State); + EnterRule(_localctx, 200, RULE_enumConstantList); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 1358; enumConstant(); + State = 1363; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 1359; Match(COMMA); + State = 1360; enumConstant(); + } + } + } + State = 1365; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class EnumConstantContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public EnumConstantModifierContext[] enumConstantModifier() { + return GetRuleContexts(); + } + public EnumConstantModifierContext enumConstantModifier(int i) { + return GetRuleContext(i); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ClassBodyContext classBody() { + return GetRuleContext(0); + } + public ArgumentListContext argumentList() { + return GetRuleContext(0); + } + public EnumConstantContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_enumConstant; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterEnumConstant(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitEnumConstant(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitEnumConstant(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public EnumConstantContext enumConstant() { + EnumConstantContext _localctx = new EnumConstantContext(Context, State); + EnterRule(_localctx, 202, RULE_enumConstant); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1369; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 1366; enumConstantModifier(); + } + } + State = 1371; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1372; identifier(); + State = 1378; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LPAREN) { + { + State = 1373; Match(LPAREN); + State = 1375; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1374; argumentList(); + } + } + + State = 1377; Match(RPAREN); + } + } + + State = 1381; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LBRACE) { + { + State = 1380; classBody(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class EnumConstantModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public EnumConstantModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_enumConstantModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterEnumConstantModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitEnumConstantModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitEnumConstantModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public EnumConstantModifierContext enumConstantModifier() { + EnumConstantModifierContext _localctx = new EnumConstantModifierContext(Context, State); + EnterRule(_localctx, 204, RULE_enumConstantModifier); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1383; annotation(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class EnumBodyDeclarationsContext : ParserRuleContext { + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public ClassBodyDeclarationContext[] classBodyDeclaration() { + return GetRuleContexts(); + } + public ClassBodyDeclarationContext classBodyDeclaration(int i) { + return GetRuleContext(i); + } + public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_enumBodyDeclarations; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterEnumBodyDeclarations(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitEnumBodyDeclarations(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitEnumBodyDeclarations(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public EnumBodyDeclarationsContext enumBodyDeclarations() { + EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(Context, State); + EnterRule(_localctx, 206, RULE_enumBodyDeclarations); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1385; Match(SEMI); + State = 1389; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << MODULE) | (1L << NATIVE) | (1L << OPEN) | (1L << OPENS) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PROVIDES) | (1L << PUBLIC) | (1L << REQUIRES) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TO) | (1L << TRANSIENT) | (1L << USES) | (1L << VOID) | (1L << VOLATILE) | (1L << WITH))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (LBRACE - 70)) | (1L << (SEMI - 70)) | (1L << (AT - 70)) | (1L << (LT - 70)) | (1L << (Identifier - 70)))) != 0)) { + { + { + State = 1386; classBodyDeclaration(); + } + } + State = 1391; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InterfaceDeclarationContext : ParserRuleContext { + public NormalInterfaceDeclarationContext normalInterfaceDeclaration() { + return GetRuleContext(0); + } + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return GetRuleContext(0); + } + public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_interfaceDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInterfaceDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInterfaceDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInterfaceDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InterfaceDeclarationContext interfaceDeclaration() { + InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(Context, State); + EnterRule(_localctx, 208, RULE_interfaceDeclaration); + try { + State = 1394; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1392; normalInterfaceDeclaration(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1393; annotationTypeDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class NormalInterfaceDeclarationContext : ParserRuleContext { + public ITerminalNode INTERFACE() { return GetToken(Java9Parser.INTERFACE, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public InterfaceBodyContext interfaceBody() { + return GetRuleContext(0); + } + public InterfaceModifierContext[] interfaceModifier() { + return GetRuleContexts(); + } + public InterfaceModifierContext interfaceModifier(int i) { + return GetRuleContext(i); + } + public TypeParametersContext typeParameters() { + return GetRuleContext(0); + } + public ExtendsInterfacesContext extendsInterfaces() { + return GetRuleContext(0); + } + public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_normalInterfaceDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterNormalInterfaceDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitNormalInterfaceDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitNormalInterfaceDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public NormalInterfaceDeclarationContext normalInterfaceDeclaration() { + NormalInterfaceDeclarationContext _localctx = new NormalInterfaceDeclarationContext(Context, State); + EnterRule(_localctx, 210, RULE_normalInterfaceDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1399; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + State = 1396; interfaceModifier(); + } + } + State = 1401; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1402; Match(INTERFACE); + State = 1403; identifier(); + State = 1405; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 1404; typeParameters(); + } + } + + State = 1408; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==EXTENDS) { + { + State = 1407; extendsInterfaces(); + } + } + + State = 1410; interfaceBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InterfaceModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public ITerminalNode PUBLIC() { return GetToken(Java9Parser.PUBLIC, 0); } + public ITerminalNode PROTECTED() { return GetToken(Java9Parser.PROTECTED, 0); } + public ITerminalNode PRIVATE() { return GetToken(Java9Parser.PRIVATE, 0); } + public ITerminalNode ABSTRACT() { return GetToken(Java9Parser.ABSTRACT, 0); } + public ITerminalNode STATIC() { return GetToken(Java9Parser.STATIC, 0); } + public ITerminalNode STRICTFP() { return GetToken(Java9Parser.STRICTFP, 0); } + public InterfaceModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_interfaceModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInterfaceModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInterfaceModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInterfaceModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InterfaceModifierContext interfaceModifier() { + InterfaceModifierContext _localctx = new InterfaceModifierContext(Context, State); + EnterRule(_localctx, 212, RULE_interfaceModifier); + try { + State = 1419; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case AT: + EnterOuterAlt(_localctx, 1); + { + State = 1412; annotation(); + } + break; + case PUBLIC: + EnterOuterAlt(_localctx, 2); + { + State = 1413; Match(PUBLIC); + } + break; + case PROTECTED: + EnterOuterAlt(_localctx, 3); + { + State = 1414; Match(PROTECTED); + } + break; + case PRIVATE: + EnterOuterAlt(_localctx, 4); + { + State = 1415; Match(PRIVATE); + } + break; + case ABSTRACT: + EnterOuterAlt(_localctx, 5); + { + State = 1416; Match(ABSTRACT); + } + break; + case STATIC: + EnterOuterAlt(_localctx, 6); + { + State = 1417; Match(STATIC); + } + break; + case STRICTFP: + EnterOuterAlt(_localctx, 7); + { + State = 1418; Match(STRICTFP); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ExtendsInterfacesContext : ParserRuleContext { + public ITerminalNode EXTENDS() { return GetToken(Java9Parser.EXTENDS, 0); } + public InterfaceTypeListContext interfaceTypeList() { + return GetRuleContext(0); + } + public ExtendsInterfacesContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_extendsInterfaces; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterExtendsInterfaces(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitExtendsInterfaces(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitExtendsInterfaces(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ExtendsInterfacesContext extendsInterfaces() { + ExtendsInterfacesContext _localctx = new ExtendsInterfacesContext(Context, State); + EnterRule(_localctx, 214, RULE_extendsInterfaces); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1421; Match(EXTENDS); + State = 1422; interfaceTypeList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InterfaceBodyContext : ParserRuleContext { + public ITerminalNode LBRACE() { return GetToken(Java9Parser.LBRACE, 0); } + public ITerminalNode RBRACE() { return GetToken(Java9Parser.RBRACE, 0); } + public InterfaceMemberDeclarationContext[] interfaceMemberDeclaration() { + return GetRuleContexts(); + } + public InterfaceMemberDeclarationContext interfaceMemberDeclaration(int i) { + return GetRuleContext(i); + } + public InterfaceBodyContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_interfaceBody; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInterfaceBody(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInterfaceBody(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInterfaceBody(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InterfaceBodyContext interfaceBody() { + InterfaceBodyContext _localctx = new InterfaceBodyContext(Context, State); + EnterRule(_localctx, 216, RULE_interfaceBody); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1424; Match(LBRACE); + State = 1428; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DEFAULT) | (1L << DOUBLE) | (1L << ENUM) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << MODULE) | (1L << OPEN) | (1L << OPENS) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PROVIDES) | (1L << PUBLIC) | (1L << REQUIRES) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (SEMI - 74)) | (1L << (AT - 74)) | (1L << (LT - 74)) | (1L << (Identifier - 74)))) != 0)) { + { + { + State = 1425; interfaceMemberDeclaration(); + } + } + State = 1430; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1431; Match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InterfaceMemberDeclarationContext : ParserRuleContext { + public ConstantDeclarationContext constantDeclaration() { + return GetRuleContext(0); + } + public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { + return GetRuleContext(0); + } + public ClassDeclarationContext classDeclaration() { + return GetRuleContext(0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_interfaceMemberDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInterfaceMemberDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInterfaceMemberDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInterfaceMemberDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InterfaceMemberDeclarationContext interfaceMemberDeclaration() { + InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(Context, State); + EnterRule(_localctx, 218, RULE_interfaceMemberDeclaration); + try { + State = 1438; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,142,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1433; constantDeclaration(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1434; interfaceMethodDeclaration(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1435; classDeclaration(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 1436; interfaceDeclaration(); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 1437; Match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ConstantDeclarationContext : ParserRuleContext { + public UnannTypeContext unannType() { + return GetRuleContext(0); + } + public VariableDeclaratorListContext variableDeclaratorList() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public ConstantModifierContext[] constantModifier() { + return GetRuleContexts(); + } + public ConstantModifierContext constantModifier(int i) { + return GetRuleContext(i); + } + public ConstantDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_constantDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterConstantDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitConstantDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitConstantDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ConstantDeclarationContext constantDeclaration() { + ConstantDeclarationContext _localctx = new ConstantDeclarationContext(Context, State); + EnterRule(_localctx, 220, RULE_constantDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1443; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (((((_la - 19)) & ~0x3f) == 0 && ((1L << (_la - 19)) & ((1L << (FINAL - 19)) | (1L << (PUBLIC - 19)) | (1L << (STATIC - 19)) | (1L << (AT - 19)))) != 0)) { + { + { + State = 1440; constantModifier(); + } + } + State = 1445; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1446; unannType(); + State = 1447; variableDeclaratorList(); + State = 1448; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ConstantModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public ITerminalNode PUBLIC() { return GetToken(Java9Parser.PUBLIC, 0); } + public ITerminalNode STATIC() { return GetToken(Java9Parser.STATIC, 0); } + public ITerminalNode FINAL() { return GetToken(Java9Parser.FINAL, 0); } + public ConstantModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_constantModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterConstantModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitConstantModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitConstantModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ConstantModifierContext constantModifier() { + ConstantModifierContext _localctx = new ConstantModifierContext(Context, State); + EnterRule(_localctx, 222, RULE_constantModifier); + try { + State = 1454; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case AT: + EnterOuterAlt(_localctx, 1); + { + State = 1450; annotation(); + } + break; + case PUBLIC: + EnterOuterAlt(_localctx, 2); + { + State = 1451; Match(PUBLIC); + } + break; + case STATIC: + EnterOuterAlt(_localctx, 3); + { + State = 1452; Match(STATIC); + } + break; + case FINAL: + EnterOuterAlt(_localctx, 4); + { + State = 1453; Match(FINAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InterfaceMethodDeclarationContext : ParserRuleContext { + public MethodHeaderContext methodHeader() { + return GetRuleContext(0); + } + public MethodBodyContext methodBody() { + return GetRuleContext(0); + } + public InterfaceMethodModifierContext[] interfaceMethodModifier() { + return GetRuleContexts(); + } + public InterfaceMethodModifierContext interfaceMethodModifier(int i) { + return GetRuleContext(i); + } + public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_interfaceMethodDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInterfaceMethodDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInterfaceMethodDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInterfaceMethodDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { + InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(Context, State); + EnterRule(_localctx, 224, RULE_interfaceMethodDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1459; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << DEFAULT) | (1L << PRIVATE) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + State = 1456; interfaceMethodModifier(); + } + } + State = 1461; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1462; methodHeader(); + State = 1463; methodBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InterfaceMethodModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public ITerminalNode PUBLIC() { return GetToken(Java9Parser.PUBLIC, 0); } + public ITerminalNode PRIVATE() { return GetToken(Java9Parser.PRIVATE, 0); } + public ITerminalNode ABSTRACT() { return GetToken(Java9Parser.ABSTRACT, 0); } + public ITerminalNode DEFAULT() { return GetToken(Java9Parser.DEFAULT, 0); } + public ITerminalNode STATIC() { return GetToken(Java9Parser.STATIC, 0); } + public ITerminalNode STRICTFP() { return GetToken(Java9Parser.STRICTFP, 0); } + public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_interfaceMethodModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInterfaceMethodModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInterfaceMethodModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInterfaceMethodModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InterfaceMethodModifierContext interfaceMethodModifier() { + InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(Context, State); + EnterRule(_localctx, 226, RULE_interfaceMethodModifier); + try { + State = 1472; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case AT: + EnterOuterAlt(_localctx, 1); + { + State = 1465; annotation(); + } + break; + case PUBLIC: + EnterOuterAlt(_localctx, 2); + { + State = 1466; Match(PUBLIC); + } + break; + case PRIVATE: + EnterOuterAlt(_localctx, 3); + { + State = 1467; Match(PRIVATE); + } + break; + case ABSTRACT: + EnterOuterAlt(_localctx, 4); + { + State = 1468; Match(ABSTRACT); + } + break; + case DEFAULT: + EnterOuterAlt(_localctx, 5); + { + State = 1469; Match(DEFAULT); + } + break; + case STATIC: + EnterOuterAlt(_localctx, 6); + { + State = 1470; Match(STATIC); + } + break; + case STRICTFP: + EnterOuterAlt(_localctx, 7); + { + State = 1471; Match(STRICTFP); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AnnotationTypeDeclarationContext : ParserRuleContext { + public ITerminalNode AT() { return GetToken(Java9Parser.AT, 0); } + public ITerminalNode INTERFACE() { return GetToken(Java9Parser.INTERFACE, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public AnnotationTypeBodyContext annotationTypeBody() { + return GetRuleContext(0); + } + public InterfaceModifierContext[] interfaceModifier() { + return GetRuleContexts(); + } + public InterfaceModifierContext interfaceModifier(int i) { + return GetRuleContext(i); + } + public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_annotationTypeDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAnnotationTypeDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAnnotationTypeDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAnnotationTypeDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(Context, State); + EnterRule(_localctx, 228, RULE_annotationTypeDeclaration); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 1477; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,147,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 1474; interfaceModifier(); + } + } + } + State = 1479; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,147,Context); + } + State = 1480; Match(AT); + State = 1481; Match(INTERFACE); + State = 1482; identifier(); + State = 1483; annotationTypeBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AnnotationTypeBodyContext : ParserRuleContext { + public ITerminalNode LBRACE() { return GetToken(Java9Parser.LBRACE, 0); } + public ITerminalNode RBRACE() { return GetToken(Java9Parser.RBRACE, 0); } + public AnnotationTypeMemberDeclarationContext[] annotationTypeMemberDeclaration() { + return GetRuleContexts(); + } + public AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration(int i) { + return GetRuleContext(i); + } + public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_annotationTypeBody; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAnnotationTypeBody(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAnnotationTypeBody(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAnnotationTypeBody(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AnnotationTypeBodyContext annotationTypeBody() { + AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(Context, State); + EnterRule(_localctx, 230, RULE_annotationTypeBody); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1485; Match(LBRACE); + State = 1489; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << MODULE) | (1L << OPEN) | (1L << OPENS) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PROVIDES) | (1L << PUBLIC) | (1L << REQUIRES) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << TO) | (1L << USES) | (1L << WITH))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (SEMI - 74)) | (1L << (AT - 74)) | (1L << (Identifier - 74)))) != 0)) { + { + { + State = 1486; annotationTypeMemberDeclaration(); + } + } + State = 1491; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1492; Match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AnnotationTypeMemberDeclarationContext : ParserRuleContext { + public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() { + return GetRuleContext(0); + } + public ConstantDeclarationContext constantDeclaration() { + return GetRuleContext(0); + } + public ClassDeclarationContext classDeclaration() { + return GetRuleContext(0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public AnnotationTypeMemberDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_annotationTypeMemberDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAnnotationTypeMemberDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAnnotationTypeMemberDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAnnotationTypeMemberDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration() { + AnnotationTypeMemberDeclarationContext _localctx = new AnnotationTypeMemberDeclarationContext(Context, State); + EnterRule(_localctx, 232, RULE_annotationTypeMemberDeclaration); + try { + State = 1499; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,149,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1494; annotationTypeElementDeclaration(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1495; constantDeclaration(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1496; classDeclaration(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 1497; interfaceDeclaration(); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 1498; Match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AnnotationTypeElementDeclarationContext : ParserRuleContext { + public UnannTypeContext unannType() { + return GetRuleContext(0); + } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public AnnotationTypeElementModifierContext[] annotationTypeElementModifier() { + return GetRuleContexts(); + } + public AnnotationTypeElementModifierContext annotationTypeElementModifier(int i) { + return GetRuleContext(i); + } + public DimsContext dims() { + return GetRuleContext(0); + } + public DefaultValueContext defaultValue() { + return GetRuleContext(0); + } + public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_annotationTypeElementDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAnnotationTypeElementDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAnnotationTypeElementDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAnnotationTypeElementDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() { + AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(Context, State); + EnterRule(_localctx, 234, RULE_annotationTypeElementDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1504; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==ABSTRACT || _la==PUBLIC || _la==AT) { + { + { + State = 1501; annotationTypeElementModifier(); + } + } + State = 1506; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1507; unannType(); + State = 1508; identifier(); + State = 1509; Match(LPAREN); + State = 1510; Match(RPAREN); + State = 1512; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LBRACK || _la==AT) { + { + State = 1511; dims(); + } + } + + State = 1515; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==DEFAULT) { + { + State = 1514; defaultValue(); + } + } + + State = 1517; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AnnotationTypeElementModifierContext : ParserRuleContext { + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public ITerminalNode PUBLIC() { return GetToken(Java9Parser.PUBLIC, 0); } + public ITerminalNode ABSTRACT() { return GetToken(Java9Parser.ABSTRACT, 0); } + public AnnotationTypeElementModifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_annotationTypeElementModifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAnnotationTypeElementModifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAnnotationTypeElementModifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAnnotationTypeElementModifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AnnotationTypeElementModifierContext annotationTypeElementModifier() { + AnnotationTypeElementModifierContext _localctx = new AnnotationTypeElementModifierContext(Context, State); + EnterRule(_localctx, 236, RULE_annotationTypeElementModifier); + try { + State = 1522; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case AT: + EnterOuterAlt(_localctx, 1); + { + State = 1519; annotation(); + } + break; + case PUBLIC: + EnterOuterAlt(_localctx, 2); + { + State = 1520; Match(PUBLIC); + } + break; + case ABSTRACT: + EnterOuterAlt(_localctx, 3); + { + State = 1521; Match(ABSTRACT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class DefaultValueContext : ParserRuleContext { + public ITerminalNode DEFAULT() { return GetToken(Java9Parser.DEFAULT, 0); } + public ElementValueContext elementValue() { + return GetRuleContext(0); + } + public DefaultValueContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_defaultValue; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterDefaultValue(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitDefaultValue(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitDefaultValue(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public DefaultValueContext defaultValue() { + DefaultValueContext _localctx = new DefaultValueContext(Context, State); + EnterRule(_localctx, 238, RULE_defaultValue); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1524; Match(DEFAULT); + State = 1525; elementValue(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AnnotationContext : ParserRuleContext { + public NormalAnnotationContext normalAnnotation() { + return GetRuleContext(0); + } + public MarkerAnnotationContext markerAnnotation() { + return GetRuleContext(0); + } + public SingleElementAnnotationContext singleElementAnnotation() { + return GetRuleContext(0); + } + public AnnotationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_annotation; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAnnotation(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAnnotation(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAnnotation(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AnnotationContext annotation() { + AnnotationContext _localctx = new AnnotationContext(Context, State); + EnterRule(_localctx, 240, RULE_annotation); + try { + State = 1530; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,154,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1527; normalAnnotation(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1528; markerAnnotation(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1529; singleElementAnnotation(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class NormalAnnotationContext : ParserRuleContext { + public ITerminalNode AT() { return GetToken(Java9Parser.AT, 0); } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ElementValuePairListContext elementValuePairList() { + return GetRuleContext(0); + } + public NormalAnnotationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_normalAnnotation; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterNormalAnnotation(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitNormalAnnotation(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitNormalAnnotation(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public NormalAnnotationContext normalAnnotation() { + NormalAnnotationContext _localctx = new NormalAnnotationContext(Context, State); + EnterRule(_localctx, 242, RULE_normalAnnotation); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1532; Match(AT); + State = 1533; typeName(); + State = 1534; Match(LPAREN); + State = 1536; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXPORTS) | (1L << MODULE) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << TO) | (1L << USES) | (1L << WITH))) != 0) || _la==Identifier) { + { + State = 1535; elementValuePairList(); + } + } + + State = 1538; Match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ElementValuePairListContext : ParserRuleContext { + public ElementValuePairContext[] elementValuePair() { + return GetRuleContexts(); + } + public ElementValuePairContext elementValuePair(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public ElementValuePairListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_elementValuePairList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterElementValuePairList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitElementValuePairList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitElementValuePairList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ElementValuePairListContext elementValuePairList() { + ElementValuePairListContext _localctx = new ElementValuePairListContext(Context, State); + EnterRule(_localctx, 244, RULE_elementValuePairList); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1540; elementValuePair(); + State = 1545; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 1541; Match(COMMA); + State = 1542; elementValuePair(); + } + } + State = 1547; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ElementValuePairContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ITerminalNode ASSIGN() { return GetToken(Java9Parser.ASSIGN, 0); } + public ElementValueContext elementValue() { + return GetRuleContext(0); + } + public ElementValuePairContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_elementValuePair; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterElementValuePair(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitElementValuePair(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitElementValuePair(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ElementValuePairContext elementValuePair() { + ElementValuePairContext _localctx = new ElementValuePairContext(Context, State); + EnterRule(_localctx, 246, RULE_elementValuePair); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1548; identifier(); + State = 1549; Match(ASSIGN); + State = 1550; elementValue(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ElementValueContext : ParserRuleContext { + public ConditionalExpressionContext conditionalExpression() { + return GetRuleContext(0); + } + public ElementValueArrayInitializerContext elementValueArrayInitializer() { + return GetRuleContext(0); + } + public AnnotationContext annotation() { + return GetRuleContext(0); + } + public ElementValueContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_elementValue; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterElementValue(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitElementValue(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitElementValue(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ElementValueContext elementValue() { + ElementValueContext _localctx = new ElementValueContext(Context, State); + EnterRule(_localctx, 248, RULE_elementValue); + try { + State = 1555; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,157,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1552; conditionalExpression(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1553; elementValueArrayInitializer(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1554; annotation(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ElementValueArrayInitializerContext : ParserRuleContext { + public ITerminalNode LBRACE() { return GetToken(Java9Parser.LBRACE, 0); } + public ITerminalNode RBRACE() { return GetToken(Java9Parser.RBRACE, 0); } + public ElementValueListContext elementValueList() { + return GetRuleContext(0); + } + public ITerminalNode COMMA() { return GetToken(Java9Parser.COMMA, 0); } + public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_elementValueArrayInitializer; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterElementValueArrayInitializer(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitElementValueArrayInitializer(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitElementValueArrayInitializer(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ElementValueArrayInitializerContext elementValueArrayInitializer() { + ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(Context, State); + EnterRule(_localctx, 250, RULE_elementValueArrayInitializer); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1557; Match(LBRACE); + State = 1559; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACE - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1558; elementValueList(); + } + } + + State = 1562; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==COMMA) { + { + State = 1561; Match(COMMA); + } + } + + State = 1564; Match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ElementValueListContext : ParserRuleContext { + public ElementValueContext[] elementValue() { + return GetRuleContexts(); + } + public ElementValueContext elementValue(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public ElementValueListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_elementValueList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterElementValueList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitElementValueList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitElementValueList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ElementValueListContext elementValueList() { + ElementValueListContext _localctx = new ElementValueListContext(Context, State); + EnterRule(_localctx, 252, RULE_elementValueList); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 1566; elementValue(); + State = 1571; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,160,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 1567; Match(COMMA); + State = 1568; elementValue(); + } + } + } + State = 1573; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,160,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MarkerAnnotationContext : ParserRuleContext { + public ITerminalNode AT() { return GetToken(Java9Parser.AT, 0); } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public MarkerAnnotationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_markerAnnotation; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMarkerAnnotation(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMarkerAnnotation(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMarkerAnnotation(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MarkerAnnotationContext markerAnnotation() { + MarkerAnnotationContext _localctx = new MarkerAnnotationContext(Context, State); + EnterRule(_localctx, 254, RULE_markerAnnotation); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1574; Match(AT); + State = 1575; typeName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SingleElementAnnotationContext : ParserRuleContext { + public ITerminalNode AT() { return GetToken(Java9Parser.AT, 0); } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ElementValueContext elementValue() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public SingleElementAnnotationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_singleElementAnnotation; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSingleElementAnnotation(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSingleElementAnnotation(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSingleElementAnnotation(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SingleElementAnnotationContext singleElementAnnotation() { + SingleElementAnnotationContext _localctx = new SingleElementAnnotationContext(Context, State); + EnterRule(_localctx, 256, RULE_singleElementAnnotation); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1577; Match(AT); + State = 1578; typeName(); + State = 1579; Match(LPAREN); + State = 1580; elementValue(); + State = 1581; Match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ArrayInitializerContext : ParserRuleContext { + public ITerminalNode LBRACE() { return GetToken(Java9Parser.LBRACE, 0); } + public ITerminalNode RBRACE() { return GetToken(Java9Parser.RBRACE, 0); } + public VariableInitializerListContext variableInitializerList() { + return GetRuleContext(0); + } + public ITerminalNode COMMA() { return GetToken(Java9Parser.COMMA, 0); } + public ArrayInitializerContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_arrayInitializer; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterArrayInitializer(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitArrayInitializer(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitArrayInitializer(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ArrayInitializerContext arrayInitializer() { + ArrayInitializerContext _localctx = new ArrayInitializerContext(Context, State); + EnterRule(_localctx, 258, RULE_arrayInitializer); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1583; Match(LBRACE); + State = 1585; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACE - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1584; variableInitializerList(); + } + } + + State = 1588; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==COMMA) { + { + State = 1587; Match(COMMA); + } + } + + State = 1590; Match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class VariableInitializerListContext : ParserRuleContext { + public VariableInitializerContext[] variableInitializer() { + return GetRuleContexts(); + } + public VariableInitializerContext variableInitializer(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public VariableInitializerListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_variableInitializerList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterVariableInitializerList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitVariableInitializerList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitVariableInitializerList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public VariableInitializerListContext variableInitializerList() { + VariableInitializerListContext _localctx = new VariableInitializerListContext(Context, State); + EnterRule(_localctx, 260, RULE_variableInitializerList); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 1592; variableInitializer(); + State = 1597; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,163,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 1593; Match(COMMA); + State = 1594; variableInitializer(); + } + } + } + State = 1599; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,163,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class BlockContext : ParserRuleContext { + public ITerminalNode LBRACE() { return GetToken(Java9Parser.LBRACE, 0); } + public ITerminalNode RBRACE() { return GetToken(Java9Parser.RBRACE, 0); } + public BlockStatementsContext blockStatements() { + return GetRuleContext(0); + } + public BlockContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_block; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterBlock(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitBlock(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitBlock(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public BlockContext block() { + BlockContext _localctx = new BlockContext(Context, State); + EnterRule(_localctx, 262, RULE_block); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1600; Match(LBRACE); + State = 1602; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PROVIDES) | (1L << PUBLIC) | (1L << REQUIRES) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L << SYNCHRONIZED) | (1L << THIS) | (1L << THROW) | (1L << TO) | (1L << TRY) | (1L << USES) | (1L << VOID) | (1L << WHILE) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (AT - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1601; blockStatements(); + } + } + + State = 1604; Match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class BlockStatementsContext : ParserRuleContext { + public BlockStatementContext[] blockStatement() { + return GetRuleContexts(); + } + public BlockStatementContext blockStatement(int i) { + return GetRuleContext(i); + } + public BlockStatementsContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_blockStatements; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterBlockStatements(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitBlockStatements(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitBlockStatements(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public BlockStatementsContext blockStatements() { + BlockStatementsContext _localctx = new BlockStatementsContext(Context, State); + EnterRule(_localctx, 264, RULE_blockStatements); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1607; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + do { + { + { + State = 1606; blockStatement(); + } + } + State = 1609; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PROVIDES) | (1L << PUBLIC) | (1L << REQUIRES) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L << SYNCHRONIZED) | (1L << THIS) | (1L << THROW) | (1L << TO) | (1L << TRY) | (1L << USES) | (1L << VOID) | (1L << WHILE) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (AT - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0) ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class BlockStatementContext : ParserRuleContext { + public LocalVariableDeclarationStatementContext localVariableDeclarationStatement() { + return GetRuleContext(0); + } + public ClassDeclarationContext classDeclaration() { + return GetRuleContext(0); + } + public StatementContext statement() { + return GetRuleContext(0); + } + public BlockStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_blockStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterBlockStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitBlockStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitBlockStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public BlockStatementContext blockStatement() { + BlockStatementContext _localctx = new BlockStatementContext(Context, State); + EnterRule(_localctx, 266, RULE_blockStatement); + try { + State = 1614; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,166,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1611; localVariableDeclarationStatement(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1612; classDeclaration(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1613; statement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class LocalVariableDeclarationStatementContext : ParserRuleContext { + public LocalVariableDeclarationContext localVariableDeclaration() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public LocalVariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_localVariableDeclarationStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterLocalVariableDeclarationStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitLocalVariableDeclarationStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitLocalVariableDeclarationStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public LocalVariableDeclarationStatementContext localVariableDeclarationStatement() { + LocalVariableDeclarationStatementContext _localctx = new LocalVariableDeclarationStatementContext(Context, State); + EnterRule(_localctx, 268, RULE_localVariableDeclarationStatement); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1616; localVariableDeclaration(); + State = 1617; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class LocalVariableDeclarationContext : ParserRuleContext { + public UnannTypeContext unannType() { + return GetRuleContext(0); + } + public VariableDeclaratorListContext variableDeclaratorList() { + return GetRuleContext(0); + } + public VariableModifierContext[] variableModifier() { + return GetRuleContexts(); + } + public VariableModifierContext variableModifier(int i) { + return GetRuleContext(i); + } + public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_localVariableDeclaration; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterLocalVariableDeclaration(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitLocalVariableDeclaration(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitLocalVariableDeclaration(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public LocalVariableDeclarationContext localVariableDeclaration() { + LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(Context, State); + EnterRule(_localctx, 270, RULE_localVariableDeclaration); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1622; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==FINAL || _la==AT) { + { + { + State = 1619; variableModifier(); + } + } + State = 1624; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1625; unannType(); + State = 1626; variableDeclaratorList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class StatementContext : ParserRuleContext { + public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() { + return GetRuleContext(0); + } + public LabeledStatementContext labeledStatement() { + return GetRuleContext(0); + } + public IfThenStatementContext ifThenStatement() { + return GetRuleContext(0); + } + public IfThenElseStatementContext ifThenElseStatement() { + return GetRuleContext(0); + } + public WhileStatementContext whileStatement() { + return GetRuleContext(0); + } + public ForStatementContext forStatement() { + return GetRuleContext(0); + } + public StatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_statement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public StatementContext statement() { + StatementContext _localctx = new StatementContext(Context, State); + EnterRule(_localctx, 272, RULE_statement); + try { + State = 1634; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,168,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1628; statementWithoutTrailingSubstatement(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1629; labeledStatement(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1630; ifThenStatement(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 1631; ifThenElseStatement(); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 1632; whileStatement(); + } + break; + case 6: + EnterOuterAlt(_localctx, 6); + { + State = 1633; forStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class StatementNoShortIfContext : ParserRuleContext { + public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() { + return GetRuleContext(0); + } + public LabeledStatementNoShortIfContext labeledStatementNoShortIf() { + return GetRuleContext(0); + } + public IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() { + return GetRuleContext(0); + } + public WhileStatementNoShortIfContext whileStatementNoShortIf() { + return GetRuleContext(0); + } + public ForStatementNoShortIfContext forStatementNoShortIf() { + return GetRuleContext(0); + } + public StatementNoShortIfContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_statementNoShortIf; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterStatementNoShortIf(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitStatementNoShortIf(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitStatementNoShortIf(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public StatementNoShortIfContext statementNoShortIf() { + StatementNoShortIfContext _localctx = new StatementNoShortIfContext(Context, State); + EnterRule(_localctx, 274, RULE_statementNoShortIf); + try { + State = 1641; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,169,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1636; statementWithoutTrailingSubstatement(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1637; labeledStatementNoShortIf(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1638; ifThenElseStatementNoShortIf(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 1639; whileStatementNoShortIf(); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 1640; forStatementNoShortIf(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class StatementWithoutTrailingSubstatementContext : ParserRuleContext { + public BlockContext block() { + return GetRuleContext(0); + } + public EmptyStatementContext emptyStatement() { + return GetRuleContext(0); + } + public ExpressionStatementContext expressionStatement() { + return GetRuleContext(0); + } + public AssertStatementContext assertStatement() { + return GetRuleContext(0); + } + public SwitchStatementContext switchStatement() { + return GetRuleContext(0); + } + public DoStatementContext doStatement() { + return GetRuleContext(0); + } + public BreakStatementContext breakStatement() { + return GetRuleContext(0); + } + public ContinueStatementContext continueStatement() { + return GetRuleContext(0); + } + public ReturnStatementContext returnStatement() { + return GetRuleContext(0); + } + public SynchronizedStatementContext synchronizedStatement() { + return GetRuleContext(0); + } + public ThrowStatementContext throwStatement() { + return GetRuleContext(0); + } + public TryStatementContext tryStatement() { + return GetRuleContext(0); + } + public StatementWithoutTrailingSubstatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_statementWithoutTrailingSubstatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterStatementWithoutTrailingSubstatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitStatementWithoutTrailingSubstatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitStatementWithoutTrailingSubstatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() { + StatementWithoutTrailingSubstatementContext _localctx = new StatementWithoutTrailingSubstatementContext(Context, State); + EnterRule(_localctx, 276, RULE_statementWithoutTrailingSubstatement); + try { + State = 1655; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case LBRACE: + EnterOuterAlt(_localctx, 1); + { + State = 1643; block(); + } + break; + case SEMI: + EnterOuterAlt(_localctx, 2); + { + State = 1644; emptyStatement(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case EXPORTS: + case FLOAT: + case INT: + case LONG: + case MODULE: + case NEW: + case OPEN: + case OPENS: + case PROVIDES: + case REQUIRES: + case SHORT: + case SUPER: + case THIS: + case TO: + case USES: + case VOID: + case WITH: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case AT: + case INC: + case DEC: + case Identifier: + EnterOuterAlt(_localctx, 3); + { + State = 1645; expressionStatement(); + } + break; + case ASSERT: + EnterOuterAlt(_localctx, 4); + { + State = 1646; assertStatement(); + } + break; + case SWITCH: + EnterOuterAlt(_localctx, 5); + { + State = 1647; switchStatement(); + } + break; + case DO: + EnterOuterAlt(_localctx, 6); + { + State = 1648; doStatement(); + } + break; + case BREAK: + EnterOuterAlt(_localctx, 7); + { + State = 1649; breakStatement(); + } + break; + case CONTINUE: + EnterOuterAlt(_localctx, 8); + { + State = 1650; continueStatement(); + } + break; + case RETURN: + EnterOuterAlt(_localctx, 9); + { + State = 1651; returnStatement(); + } + break; + case SYNCHRONIZED: + EnterOuterAlt(_localctx, 10); + { + State = 1652; synchronizedStatement(); + } + break; + case THROW: + EnterOuterAlt(_localctx, 11); + { + State = 1653; throwStatement(); + } + break; + case TRY: + EnterOuterAlt(_localctx, 12); + { + State = 1654; tryStatement(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class EmptyStatementContext : ParserRuleContext { + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public EmptyStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_emptyStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterEmptyStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitEmptyStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitEmptyStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public EmptyStatementContext emptyStatement() { + EmptyStatementContext _localctx = new EmptyStatementContext(Context, State); + EnterRule(_localctx, 278, RULE_emptyStatement); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1657; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class LabeledStatementContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ITerminalNode COLON() { return GetToken(Java9Parser.COLON, 0); } + public StatementContext statement() { + return GetRuleContext(0); + } + public LabeledStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_labeledStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterLabeledStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitLabeledStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitLabeledStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public LabeledStatementContext labeledStatement() { + LabeledStatementContext _localctx = new LabeledStatementContext(Context, State); + EnterRule(_localctx, 280, RULE_labeledStatement); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1659; identifier(); + State = 1660; Match(COLON); + State = 1661; statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class LabeledStatementNoShortIfContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ITerminalNode COLON() { return GetToken(Java9Parser.COLON, 0); } + public StatementNoShortIfContext statementNoShortIf() { + return GetRuleContext(0); + } + public LabeledStatementNoShortIfContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_labeledStatementNoShortIf; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterLabeledStatementNoShortIf(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitLabeledStatementNoShortIf(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitLabeledStatementNoShortIf(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public LabeledStatementNoShortIfContext labeledStatementNoShortIf() { + LabeledStatementNoShortIfContext _localctx = new LabeledStatementNoShortIfContext(Context, State); + EnterRule(_localctx, 282, RULE_labeledStatementNoShortIf); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1663; identifier(); + State = 1664; Match(COLON); + State = 1665; statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ExpressionStatementContext : ParserRuleContext { + public StatementExpressionContext statementExpression() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public ExpressionStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_expressionStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterExpressionStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitExpressionStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitExpressionStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ExpressionStatementContext expressionStatement() { + ExpressionStatementContext _localctx = new ExpressionStatementContext(Context, State); + EnterRule(_localctx, 284, RULE_expressionStatement); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1667; statementExpression(); + State = 1668; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class StatementExpressionContext : ParserRuleContext { + public AssignmentContext assignment() { + return GetRuleContext(0); + } + public PreIncrementExpressionContext preIncrementExpression() { + return GetRuleContext(0); + } + public PreDecrementExpressionContext preDecrementExpression() { + return GetRuleContext(0); + } + public PostIncrementExpressionContext postIncrementExpression() { + return GetRuleContext(0); + } + public PostDecrementExpressionContext postDecrementExpression() { + return GetRuleContext(0); + } + public MethodInvocationContext methodInvocation() { + return GetRuleContext(0); + } + public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { + return GetRuleContext(0); + } + public StatementExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_statementExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterStatementExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitStatementExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitStatementExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public StatementExpressionContext statementExpression() { + StatementExpressionContext _localctx = new StatementExpressionContext(Context, State); + EnterRule(_localctx, 286, RULE_statementExpression); + try { + State = 1677; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,171,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1670; assignment(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1671; preIncrementExpression(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1672; preDecrementExpression(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 1673; postIncrementExpression(); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 1674; postDecrementExpression(); + } + break; + case 6: + EnterOuterAlt(_localctx, 6); + { + State = 1675; methodInvocation(); + } + break; + case 7: + EnterOuterAlt(_localctx, 7); + { + State = 1676; classInstanceCreationExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class IfThenStatementContext : ParserRuleContext { + public ITerminalNode IF() { return GetToken(Java9Parser.IF, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public StatementContext statement() { + return GetRuleContext(0); + } + public IfThenStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_ifThenStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterIfThenStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitIfThenStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitIfThenStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public IfThenStatementContext ifThenStatement() { + IfThenStatementContext _localctx = new IfThenStatementContext(Context, State); + EnterRule(_localctx, 288, RULE_ifThenStatement); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1679; Match(IF); + State = 1680; Match(LPAREN); + State = 1681; expression(); + State = 1682; Match(RPAREN); + State = 1683; statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class IfThenElseStatementContext : ParserRuleContext { + public ITerminalNode IF() { return GetToken(Java9Parser.IF, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public StatementNoShortIfContext statementNoShortIf() { + return GetRuleContext(0); + } + public ITerminalNode ELSE() { return GetToken(Java9Parser.ELSE, 0); } + public StatementContext statement() { + return GetRuleContext(0); + } + public IfThenElseStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_ifThenElseStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterIfThenElseStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitIfThenElseStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitIfThenElseStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public IfThenElseStatementContext ifThenElseStatement() { + IfThenElseStatementContext _localctx = new IfThenElseStatementContext(Context, State); + EnterRule(_localctx, 290, RULE_ifThenElseStatement); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1685; Match(IF); + State = 1686; Match(LPAREN); + State = 1687; expression(); + State = 1688; Match(RPAREN); + State = 1689; statementNoShortIf(); + State = 1690; Match(ELSE); + State = 1691; statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class IfThenElseStatementNoShortIfContext : ParserRuleContext { + public ITerminalNode IF() { return GetToken(Java9Parser.IF, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public StatementNoShortIfContext[] statementNoShortIf() { + return GetRuleContexts(); + } + public StatementNoShortIfContext statementNoShortIf(int i) { + return GetRuleContext(i); + } + public ITerminalNode ELSE() { return GetToken(Java9Parser.ELSE, 0); } + public IfThenElseStatementNoShortIfContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_ifThenElseStatementNoShortIf; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterIfThenElseStatementNoShortIf(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitIfThenElseStatementNoShortIf(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitIfThenElseStatementNoShortIf(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() { + IfThenElseStatementNoShortIfContext _localctx = new IfThenElseStatementNoShortIfContext(Context, State); + EnterRule(_localctx, 292, RULE_ifThenElseStatementNoShortIf); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1693; Match(IF); + State = 1694; Match(LPAREN); + State = 1695; expression(); + State = 1696; Match(RPAREN); + State = 1697; statementNoShortIf(); + State = 1698; Match(ELSE); + State = 1699; statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AssertStatementContext : ParserRuleContext { + public ITerminalNode ASSERT() { return GetToken(Java9Parser.ASSERT, 0); } + public ExpressionContext[] expression() { + return GetRuleContexts(); + } + public ExpressionContext expression(int i) { + return GetRuleContext(i); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public ITerminalNode COLON() { return GetToken(Java9Parser.COLON, 0); } + public AssertStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_assertStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAssertStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAssertStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAssertStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AssertStatementContext assertStatement() { + AssertStatementContext _localctx = new AssertStatementContext(Context, State); + EnterRule(_localctx, 294, RULE_assertStatement); + try { + State = 1711; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,172,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1701; Match(ASSERT); + State = 1702; expression(); + State = 1703; Match(SEMI); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1705; Match(ASSERT); + State = 1706; expression(); + State = 1707; Match(COLON); + State = 1708; expression(); + State = 1709; Match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SwitchStatementContext : ParserRuleContext { + public ITerminalNode SWITCH() { return GetToken(Java9Parser.SWITCH, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public SwitchBlockContext switchBlock() { + return GetRuleContext(0); + } + public SwitchStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_switchStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSwitchStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSwitchStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSwitchStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SwitchStatementContext switchStatement() { + SwitchStatementContext _localctx = new SwitchStatementContext(Context, State); + EnterRule(_localctx, 296, RULE_switchStatement); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1713; Match(SWITCH); + State = 1714; Match(LPAREN); + State = 1715; expression(); + State = 1716; Match(RPAREN); + State = 1717; switchBlock(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SwitchBlockContext : ParserRuleContext { + public ITerminalNode LBRACE() { return GetToken(Java9Parser.LBRACE, 0); } + public ITerminalNode RBRACE() { return GetToken(Java9Parser.RBRACE, 0); } + public SwitchBlockStatementGroupContext[] switchBlockStatementGroup() { + return GetRuleContexts(); + } + public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) { + return GetRuleContext(i); + } + public SwitchLabelContext[] switchLabel() { + return GetRuleContexts(); + } + public SwitchLabelContext switchLabel(int i) { + return GetRuleContext(i); + } + public SwitchBlockContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_switchBlock; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSwitchBlock(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSwitchBlock(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSwitchBlock(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SwitchBlockContext switchBlock() { + SwitchBlockContext _localctx = new SwitchBlockContext(Context, State); + EnterRule(_localctx, 298, RULE_switchBlock); + int _la; + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 1719; Match(LBRACE); + State = 1723; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,173,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 1720; switchBlockStatementGroup(); + } + } + } + State = 1725; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,173,Context); + } + State = 1729; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==CASE || _la==DEFAULT) { + { + { + State = 1726; switchLabel(); + } + } + State = 1731; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1732; Match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SwitchBlockStatementGroupContext : ParserRuleContext { + public SwitchLabelsContext switchLabels() { + return GetRuleContext(0); + } + public BlockStatementsContext blockStatements() { + return GetRuleContext(0); + } + public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_switchBlockStatementGroup; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSwitchBlockStatementGroup(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSwitchBlockStatementGroup(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSwitchBlockStatementGroup(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SwitchBlockStatementGroupContext switchBlockStatementGroup() { + SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(Context, State); + EnterRule(_localctx, 300, RULE_switchBlockStatementGroup); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1734; switchLabels(); + State = 1735; blockStatements(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SwitchLabelsContext : ParserRuleContext { + public SwitchLabelContext[] switchLabel() { + return GetRuleContexts(); + } + public SwitchLabelContext switchLabel(int i) { + return GetRuleContext(i); + } + public SwitchLabelsContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_switchLabels; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSwitchLabels(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSwitchLabels(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSwitchLabels(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SwitchLabelsContext switchLabels() { + SwitchLabelsContext _localctx = new SwitchLabelsContext(Context, State); + EnterRule(_localctx, 302, RULE_switchLabels); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1738; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + do { + { + { + State = 1737; switchLabel(); + } + } + State = 1740; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } while ( _la==CASE || _la==DEFAULT ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SwitchLabelContext : ParserRuleContext { + public ITerminalNode CASE() { return GetToken(Java9Parser.CASE, 0); } + public ConstantExpressionContext constantExpression() { + return GetRuleContext(0); + } + public ITerminalNode COLON() { return GetToken(Java9Parser.COLON, 0); } + public EnumConstantNameContext enumConstantName() { + return GetRuleContext(0); + } + public ITerminalNode DEFAULT() { return GetToken(Java9Parser.DEFAULT, 0); } + public SwitchLabelContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_switchLabel; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSwitchLabel(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSwitchLabel(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSwitchLabel(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SwitchLabelContext switchLabel() { + SwitchLabelContext _localctx = new SwitchLabelContext(Context, State); + EnterRule(_localctx, 304, RULE_switchLabel); + try { + State = 1752; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,176,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1742; Match(CASE); + State = 1743; constantExpression(); + State = 1744; Match(COLON); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1746; Match(CASE); + State = 1747; enumConstantName(); + State = 1748; Match(COLON); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1750; Match(DEFAULT); + State = 1751; Match(COLON); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class EnumConstantNameContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public EnumConstantNameContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_enumConstantName; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterEnumConstantName(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitEnumConstantName(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitEnumConstantName(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public EnumConstantNameContext enumConstantName() { + EnumConstantNameContext _localctx = new EnumConstantNameContext(Context, State); + EnterRule(_localctx, 306, RULE_enumConstantName); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1754; identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class WhileStatementContext : ParserRuleContext { + public ITerminalNode WHILE() { return GetToken(Java9Parser.WHILE, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public StatementContext statement() { + return GetRuleContext(0); + } + public WhileStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_whileStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterWhileStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitWhileStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitWhileStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public WhileStatementContext whileStatement() { + WhileStatementContext _localctx = new WhileStatementContext(Context, State); + EnterRule(_localctx, 308, RULE_whileStatement); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1756; Match(WHILE); + State = 1757; Match(LPAREN); + State = 1758; expression(); + State = 1759; Match(RPAREN); + State = 1760; statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class WhileStatementNoShortIfContext : ParserRuleContext { + public ITerminalNode WHILE() { return GetToken(Java9Parser.WHILE, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public StatementNoShortIfContext statementNoShortIf() { + return GetRuleContext(0); + } + public WhileStatementNoShortIfContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_whileStatementNoShortIf; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterWhileStatementNoShortIf(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitWhileStatementNoShortIf(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitWhileStatementNoShortIf(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public WhileStatementNoShortIfContext whileStatementNoShortIf() { + WhileStatementNoShortIfContext _localctx = new WhileStatementNoShortIfContext(Context, State); + EnterRule(_localctx, 310, RULE_whileStatementNoShortIf); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1762; Match(WHILE); + State = 1763; Match(LPAREN); + State = 1764; expression(); + State = 1765; Match(RPAREN); + State = 1766; statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class DoStatementContext : ParserRuleContext { + public ITerminalNode DO() { return GetToken(Java9Parser.DO, 0); } + public StatementContext statement() { + return GetRuleContext(0); + } + public ITerminalNode WHILE() { return GetToken(Java9Parser.WHILE, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public DoStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_doStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterDoStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitDoStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitDoStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public DoStatementContext doStatement() { + DoStatementContext _localctx = new DoStatementContext(Context, State); + EnterRule(_localctx, 312, RULE_doStatement); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1768; Match(DO); + State = 1769; statement(); + State = 1770; Match(WHILE); + State = 1771; Match(LPAREN); + State = 1772; expression(); + State = 1773; Match(RPAREN); + State = 1774; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ForStatementContext : ParserRuleContext { + public BasicForStatementContext basicForStatement() { + return GetRuleContext(0); + } + public EnhancedForStatementContext enhancedForStatement() { + return GetRuleContext(0); + } + public ForStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_forStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterForStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitForStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitForStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ForStatementContext forStatement() { + ForStatementContext _localctx = new ForStatementContext(Context, State); + EnterRule(_localctx, 314, RULE_forStatement); + try { + State = 1778; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,177,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1776; basicForStatement(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1777; enhancedForStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ForStatementNoShortIfContext : ParserRuleContext { + public BasicForStatementNoShortIfContext basicForStatementNoShortIf() { + return GetRuleContext(0); + } + public EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() { + return GetRuleContext(0); + } + public ForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_forStatementNoShortIf; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterForStatementNoShortIf(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitForStatementNoShortIf(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitForStatementNoShortIf(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ForStatementNoShortIfContext forStatementNoShortIf() { + ForStatementNoShortIfContext _localctx = new ForStatementNoShortIfContext(Context, State); + EnterRule(_localctx, 316, RULE_forStatementNoShortIf); + try { + State = 1782; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,178,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1780; basicForStatementNoShortIf(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1781; enhancedForStatementNoShortIf(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class BasicForStatementContext : ParserRuleContext { + public ITerminalNode FOR() { return GetToken(Java9Parser.FOR, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode[] SEMI() { return GetTokens(Java9Parser.SEMI); } + public ITerminalNode SEMI(int i) { + return GetToken(Java9Parser.SEMI, i); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public StatementContext statement() { + return GetRuleContext(0); + } + public ForInitContext forInit() { + return GetRuleContext(0); + } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ForUpdateContext forUpdate() { + return GetRuleContext(0); + } + public BasicForStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_basicForStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterBasicForStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitBasicForStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitBasicForStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public BasicForStatementContext basicForStatement() { + BasicForStatementContext _localctx = new BasicForStatementContext(Context, State); + EnterRule(_localctx, 318, RULE_basicForStatement); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1784; Match(FOR); + State = 1785; Match(LPAREN); + State = 1787; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1786; forInit(); + } + } + + State = 1789; Match(SEMI); + State = 1791; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1790; expression(); + } + } + + State = 1793; Match(SEMI); + State = 1795; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1794; forUpdate(); + } + } + + State = 1797; Match(RPAREN); + State = 1798; statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class BasicForStatementNoShortIfContext : ParserRuleContext { + public ITerminalNode FOR() { return GetToken(Java9Parser.FOR, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode[] SEMI() { return GetTokens(Java9Parser.SEMI); } + public ITerminalNode SEMI(int i) { + return GetToken(Java9Parser.SEMI, i); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public StatementNoShortIfContext statementNoShortIf() { + return GetRuleContext(0); + } + public ForInitContext forInit() { + return GetRuleContext(0); + } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ForUpdateContext forUpdate() { + return GetRuleContext(0); + } + public BasicForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_basicForStatementNoShortIf; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterBasicForStatementNoShortIf(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitBasicForStatementNoShortIf(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitBasicForStatementNoShortIf(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public BasicForStatementNoShortIfContext basicForStatementNoShortIf() { + BasicForStatementNoShortIfContext _localctx = new BasicForStatementNoShortIfContext(Context, State); + EnterRule(_localctx, 320, RULE_basicForStatementNoShortIf); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1800; Match(FOR); + State = 1801; Match(LPAREN); + State = 1803; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1802; forInit(); + } + } + + State = 1805; Match(SEMI); + State = 1807; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1806; expression(); + } + } + + State = 1809; Match(SEMI); + State = 1811; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1810; forUpdate(); + } + } + + State = 1813; Match(RPAREN); + State = 1814; statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ForInitContext : ParserRuleContext { + public StatementExpressionListContext statementExpressionList() { + return GetRuleContext(0); + } + public LocalVariableDeclarationContext localVariableDeclaration() { + return GetRuleContext(0); + } + public ForInitContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_forInit; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterForInit(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitForInit(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitForInit(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ForInitContext forInit() { + ForInitContext _localctx = new ForInitContext(Context, State); + EnterRule(_localctx, 322, RULE_forInit); + try { + State = 1818; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,185,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1816; statementExpressionList(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1817; localVariableDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ForUpdateContext : ParserRuleContext { + public StatementExpressionListContext statementExpressionList() { + return GetRuleContext(0); + } + public ForUpdateContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_forUpdate; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterForUpdate(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitForUpdate(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitForUpdate(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ForUpdateContext forUpdate() { + ForUpdateContext _localctx = new ForUpdateContext(Context, State); + EnterRule(_localctx, 324, RULE_forUpdate); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1820; statementExpressionList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class StatementExpressionListContext : ParserRuleContext { + public StatementExpressionContext[] statementExpression() { + return GetRuleContexts(); + } + public StatementExpressionContext statementExpression(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public StatementExpressionListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_statementExpressionList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterStatementExpressionList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitStatementExpressionList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitStatementExpressionList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public StatementExpressionListContext statementExpressionList() { + StatementExpressionListContext _localctx = new StatementExpressionListContext(Context, State); + EnterRule(_localctx, 326, RULE_statementExpressionList); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1822; statementExpression(); + State = 1827; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 1823; Match(COMMA); + State = 1824; statementExpression(); + } + } + State = 1829; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class EnhancedForStatementContext : ParserRuleContext { + public ITerminalNode FOR() { return GetToken(Java9Parser.FOR, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public UnannTypeContext unannType() { + return GetRuleContext(0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return GetRuleContext(0); + } + public ITerminalNode COLON() { return GetToken(Java9Parser.COLON, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public StatementContext statement() { + return GetRuleContext(0); + } + public VariableModifierContext[] variableModifier() { + return GetRuleContexts(); + } + public VariableModifierContext variableModifier(int i) { + return GetRuleContext(i); + } + public EnhancedForStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_enhancedForStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterEnhancedForStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitEnhancedForStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitEnhancedForStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public EnhancedForStatementContext enhancedForStatement() { + EnhancedForStatementContext _localctx = new EnhancedForStatementContext(Context, State); + EnterRule(_localctx, 328, RULE_enhancedForStatement); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1830; Match(FOR); + State = 1831; Match(LPAREN); + State = 1835; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==FINAL || _la==AT) { + { + { + State = 1832; variableModifier(); + } + } + State = 1837; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1838; unannType(); + State = 1839; variableDeclaratorId(); + State = 1840; Match(COLON); + State = 1841; expression(); + State = 1842; Match(RPAREN); + State = 1843; statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class EnhancedForStatementNoShortIfContext : ParserRuleContext { + public ITerminalNode FOR() { return GetToken(Java9Parser.FOR, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public UnannTypeContext unannType() { + return GetRuleContext(0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return GetRuleContext(0); + } + public ITerminalNode COLON() { return GetToken(Java9Parser.COLON, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public StatementNoShortIfContext statementNoShortIf() { + return GetRuleContext(0); + } + public VariableModifierContext[] variableModifier() { + return GetRuleContexts(); + } + public VariableModifierContext variableModifier(int i) { + return GetRuleContext(i); + } + public EnhancedForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_enhancedForStatementNoShortIf; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterEnhancedForStatementNoShortIf(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitEnhancedForStatementNoShortIf(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitEnhancedForStatementNoShortIf(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() { + EnhancedForStatementNoShortIfContext _localctx = new EnhancedForStatementNoShortIfContext(Context, State); + EnterRule(_localctx, 330, RULE_enhancedForStatementNoShortIf); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1845; Match(FOR); + State = 1846; Match(LPAREN); + State = 1850; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==FINAL || _la==AT) { + { + { + State = 1847; variableModifier(); + } + } + State = 1852; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1853; unannType(); + State = 1854; variableDeclaratorId(); + State = 1855; Match(COLON); + State = 1856; expression(); + State = 1857; Match(RPAREN); + State = 1858; statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class BreakStatementContext : ParserRuleContext { + public ITerminalNode BREAK() { return GetToken(Java9Parser.BREAK, 0); } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public BreakStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_breakStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterBreakStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitBreakStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitBreakStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public BreakStatementContext breakStatement() { + BreakStatementContext _localctx = new BreakStatementContext(Context, State); + EnterRule(_localctx, 332, RULE_breakStatement); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1860; Match(BREAK); + State = 1862; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXPORTS) | (1L << MODULE) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << TO) | (1L << USES) | (1L << WITH))) != 0) || _la==Identifier) { + { + State = 1861; identifier(); + } + } + + State = 1864; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ContinueStatementContext : ParserRuleContext { + public ITerminalNode CONTINUE() { return GetToken(Java9Parser.CONTINUE, 0); } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ContinueStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_continueStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterContinueStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitContinueStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitContinueStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ContinueStatementContext continueStatement() { + ContinueStatementContext _localctx = new ContinueStatementContext(Context, State); + EnterRule(_localctx, 334, RULE_continueStatement); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1866; Match(CONTINUE); + State = 1868; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXPORTS) | (1L << MODULE) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << TO) | (1L << USES) | (1L << WITH))) != 0) || _la==Identifier) { + { + State = 1867; identifier(); + } + } + + State = 1870; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ReturnStatementContext : ParserRuleContext { + public ITerminalNode RETURN() { return GetToken(Java9Parser.RETURN, 0); } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ReturnStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_returnStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterReturnStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitReturnStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitReturnStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ReturnStatementContext returnStatement() { + ReturnStatementContext _localctx = new ReturnStatementContext(Context, State); + EnterRule(_localctx, 336, RULE_returnStatement); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1872; Match(RETURN); + State = 1874; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 1873; expression(); + } + } + + State = 1876; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ThrowStatementContext : ParserRuleContext { + public ITerminalNode THROW() { return GetToken(Java9Parser.THROW, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public ThrowStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_throwStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterThrowStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitThrowStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitThrowStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ThrowStatementContext throwStatement() { + ThrowStatementContext _localctx = new ThrowStatementContext(Context, State); + EnterRule(_localctx, 338, RULE_throwStatement); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1878; Match(THROW); + State = 1879; expression(); + State = 1880; Match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class SynchronizedStatementContext : ParserRuleContext { + public ITerminalNode SYNCHRONIZED() { return GetToken(Java9Parser.SYNCHRONIZED, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public BlockContext block() { + return GetRuleContext(0); + } + public SynchronizedStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_synchronizedStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterSynchronizedStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitSynchronizedStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitSynchronizedStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public SynchronizedStatementContext synchronizedStatement() { + SynchronizedStatementContext _localctx = new SynchronizedStatementContext(Context, State); + EnterRule(_localctx, 340, RULE_synchronizedStatement); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1882; Match(SYNCHRONIZED); + State = 1883; Match(LPAREN); + State = 1884; expression(); + State = 1885; Match(RPAREN); + State = 1886; block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TryStatementContext : ParserRuleContext { + public ITerminalNode TRY() { return GetToken(Java9Parser.TRY, 0); } + public BlockContext block() { + return GetRuleContext(0); + } + public CatchesContext catches() { + return GetRuleContext(0); + } + public Finally_Context finally_() { + return GetRuleContext(0); + } + public TryWithResourcesStatementContext tryWithResourcesStatement() { + return GetRuleContext(0); + } + public TryStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_tryStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTryStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTryStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTryStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TryStatementContext tryStatement() { + TryStatementContext _localctx = new TryStatementContext(Context, State); + EnterRule(_localctx, 342, RULE_tryStatement); + int _la; + try { + State = 1900; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,193,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1888; Match(TRY); + State = 1889; block(); + State = 1890; catches(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1892; Match(TRY); + State = 1893; block(); + State = 1895; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==CATCH) { + { + State = 1894; catches(); + } + } + + State = 1897; finally_(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1899; tryWithResourcesStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class CatchesContext : ParserRuleContext { + public CatchClauseContext[] catchClause() { + return GetRuleContexts(); + } + public CatchClauseContext catchClause(int i) { + return GetRuleContext(i); + } + public CatchesContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_catches; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterCatches(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitCatches(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitCatches(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public CatchesContext catches() { + CatchesContext _localctx = new CatchesContext(Context, State); + EnterRule(_localctx, 344, RULE_catches); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1903; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + do { + { + { + State = 1902; catchClause(); + } + } + State = 1905; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } while ( _la==CATCH ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class CatchClauseContext : ParserRuleContext { + public ITerminalNode CATCH() { return GetToken(Java9Parser.CATCH, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public CatchFormalParameterContext catchFormalParameter() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public BlockContext block() { + return GetRuleContext(0); + } + public CatchClauseContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_catchClause; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterCatchClause(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitCatchClause(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitCatchClause(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public CatchClauseContext catchClause() { + CatchClauseContext _localctx = new CatchClauseContext(Context, State); + EnterRule(_localctx, 346, RULE_catchClause); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1907; Match(CATCH); + State = 1908; Match(LPAREN); + State = 1909; catchFormalParameter(); + State = 1910; Match(RPAREN); + State = 1911; block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class CatchFormalParameterContext : ParserRuleContext { + public CatchTypeContext catchType() { + return GetRuleContext(0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return GetRuleContext(0); + } + public VariableModifierContext[] variableModifier() { + return GetRuleContexts(); + } + public VariableModifierContext variableModifier(int i) { + return GetRuleContext(i); + } + public CatchFormalParameterContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_catchFormalParameter; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterCatchFormalParameter(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitCatchFormalParameter(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitCatchFormalParameter(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public CatchFormalParameterContext catchFormalParameter() { + CatchFormalParameterContext _localctx = new CatchFormalParameterContext(Context, State); + EnterRule(_localctx, 348, RULE_catchFormalParameter); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1916; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==FINAL || _la==AT) { + { + { + State = 1913; variableModifier(); + } + } + State = 1918; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1919; catchType(); + State = 1920; variableDeclaratorId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class CatchTypeContext : ParserRuleContext { + public UnannClassTypeContext unannClassType() { + return GetRuleContext(0); + } + public ITerminalNode[] BITOR() { return GetTokens(Java9Parser.BITOR); } + public ITerminalNode BITOR(int i) { + return GetToken(Java9Parser.BITOR, i); + } + public ClassTypeContext[] classType() { + return GetRuleContexts(); + } + public ClassTypeContext classType(int i) { + return GetRuleContext(i); + } + public CatchTypeContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_catchType; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterCatchType(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitCatchType(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitCatchType(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public CatchTypeContext catchType() { + CatchTypeContext _localctx = new CatchTypeContext(Context, State); + EnterRule(_localctx, 350, RULE_catchType); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1922; unannClassType(); + State = 1927; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==BITOR) { + { + { + State = 1923; Match(BITOR); + State = 1924; classType(); + } + } + State = 1929; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class Finally_Context : ParserRuleContext { + public ITerminalNode FINALLY() { return GetToken(Java9Parser.FINALLY, 0); } + public BlockContext block() { + return GetRuleContext(0); + } + public Finally_Context(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_finally_; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterFinally_(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitFinally_(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitFinally_(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public Finally_Context finally_() { + Finally_Context _localctx = new Finally_Context(Context, State); + EnterRule(_localctx, 352, RULE_finally_); + try { + EnterOuterAlt(_localctx, 1); + { + State = 1930; Match(FINALLY); + State = 1931; block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TryWithResourcesStatementContext : ParserRuleContext { + public ITerminalNode TRY() { return GetToken(Java9Parser.TRY, 0); } + public ResourceSpecificationContext resourceSpecification() { + return GetRuleContext(0); + } + public BlockContext block() { + return GetRuleContext(0); + } + public CatchesContext catches() { + return GetRuleContext(0); + } + public Finally_Context finally_() { + return GetRuleContext(0); + } + public TryWithResourcesStatementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_tryWithResourcesStatement; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTryWithResourcesStatement(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTryWithResourcesStatement(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTryWithResourcesStatement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TryWithResourcesStatementContext tryWithResourcesStatement() { + TryWithResourcesStatementContext _localctx = new TryWithResourcesStatementContext(Context, State); + EnterRule(_localctx, 354, RULE_tryWithResourcesStatement); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1933; Match(TRY); + State = 1934; resourceSpecification(); + State = 1935; block(); + State = 1937; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==CATCH) { + { + State = 1936; catches(); + } + } + + State = 1940; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==FINALLY) { + { + State = 1939; finally_(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ResourceSpecificationContext : ParserRuleContext { + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ResourceListContext resourceList() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ITerminalNode SEMI() { return GetToken(Java9Parser.SEMI, 0); } + public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_resourceSpecification; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterResourceSpecification(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitResourceSpecification(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitResourceSpecification(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ResourceSpecificationContext resourceSpecification() { + ResourceSpecificationContext _localctx = new ResourceSpecificationContext(Context, State); + EnterRule(_localctx, 356, RULE_resourceSpecification); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 1942; Match(LPAREN); + State = 1943; resourceList(); + State = 1945; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==SEMI) { + { + State = 1944; Match(SEMI); + } + } + + State = 1947; Match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ResourceListContext : ParserRuleContext { + public ResourceContext[] resource() { + return GetRuleContexts(); + } + public ResourceContext resource(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] SEMI() { return GetTokens(Java9Parser.SEMI); } + public ITerminalNode SEMI(int i) { + return GetToken(Java9Parser.SEMI, i); + } + public ResourceListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_resourceList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterResourceList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitResourceList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitResourceList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ResourceListContext resourceList() { + ResourceListContext _localctx = new ResourceListContext(Context, State); + EnterRule(_localctx, 358, RULE_resourceList); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 1949; resource(); + State = 1954; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,200,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 1950; Match(SEMI); + State = 1951; resource(); + } + } + } + State = 1956; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,200,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ResourceContext : ParserRuleContext { + public UnannTypeContext unannType() { + return GetRuleContext(0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return GetRuleContext(0); + } + public ITerminalNode ASSIGN() { return GetToken(Java9Parser.ASSIGN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public VariableModifierContext[] variableModifier() { + return GetRuleContexts(); + } + public VariableModifierContext variableModifier(int i) { + return GetRuleContext(i); + } + public VariableAccessContext variableAccess() { + return GetRuleContext(0); + } + public ResourceContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_resource; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterResource(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitResource(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitResource(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ResourceContext resource() { + ResourceContext _localctx = new ResourceContext(Context, State); + EnterRule(_localctx, 360, RULE_resource); + int _la; + try { + State = 1969; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,202,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1960; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==FINAL || _la==AT) { + { + { + State = 1957; variableModifier(); + } + } + State = 1962; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 1963; unannType(); + State = 1964; variableDeclaratorId(); + State = 1965; Match(ASSIGN); + State = 1966; expression(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1968; variableAccess(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class VariableAccessContext : ParserRuleContext { + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public FieldAccessContext fieldAccess() { + return GetRuleContext(0); + } + public VariableAccessContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_variableAccess; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterVariableAccess(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitVariableAccess(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitVariableAccess(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public VariableAccessContext variableAccess() { + VariableAccessContext _localctx = new VariableAccessContext(Context, State); + EnterRule(_localctx, 362, RULE_variableAccess); + try { + State = 1973; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,203,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1971; expressionName(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1972; fieldAccess(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PrimaryContext : ParserRuleContext { + public PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() { + return GetRuleContext(0); + } + public ArrayCreationExpressionContext arrayCreationExpression() { + return GetRuleContext(0); + } + public PrimaryNoNewArray_lf_primaryContext[] primaryNoNewArray_lf_primary() { + return GetRuleContexts(); + } + public PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary(int i) { + return GetRuleContext(i); + } + public PrimaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPrimary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPrimary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPrimary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PrimaryContext primary() { + PrimaryContext _localctx = new PrimaryContext(Context, State); + EnterRule(_localctx, 364, RULE_primary); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 1977; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,204,Context) ) { + case 1: + { + State = 1975; primaryNoNewArray_lfno_primary(); + } + break; + case 2: + { + State = 1976; arrayCreationExpression(); + } + break; + } + State = 1982; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,205,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 1979; primaryNoNewArray_lf_primary(); + } + } + } + State = 1984; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,205,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PrimaryNoNewArrayContext : ParserRuleContext { + public LiteralContext literal() { + return GetRuleContext(0); + } + public ClassLiteralContext classLiteral() { + return GetRuleContext(0); + } + public ITerminalNode THIS() { return GetToken(Java9Parser.THIS, 0); } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { + return GetRuleContext(0); + } + public FieldAccessContext fieldAccess() { + return GetRuleContext(0); + } + public ArrayAccessContext arrayAccess() { + return GetRuleContext(0); + } + public MethodInvocationContext methodInvocation() { + return GetRuleContext(0); + } + public MethodReferenceContext methodReference() { + return GetRuleContext(0); + } + public PrimaryNoNewArrayContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_primaryNoNewArray; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPrimaryNoNewArray(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPrimaryNoNewArray(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPrimaryNoNewArray(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PrimaryNoNewArrayContext primaryNoNewArray() { + PrimaryNoNewArrayContext _localctx = new PrimaryNoNewArrayContext(Context, State); + EnterRule(_localctx, 366, RULE_primaryNoNewArray); + try { + State = 2001; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,206,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 1985; literal(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 1986; classLiteral(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 1987; Match(THIS); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 1988; typeName(); + State = 1989; Match(DOT); + State = 1990; Match(THIS); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 1992; Match(LPAREN); + State = 1993; expression(); + State = 1994; Match(RPAREN); + } + break; + case 6: + EnterOuterAlt(_localctx, 6); + { + State = 1996; classInstanceCreationExpression(); + } + break; + case 7: + EnterOuterAlt(_localctx, 7); + { + State = 1997; fieldAccess(); + } + break; + case 8: + EnterOuterAlt(_localctx, 8); + { + State = 1998; arrayAccess(); + } + break; + case 9: + EnterOuterAlt(_localctx, 9); + { + State = 1999; methodInvocation(); + } + break; + case 10: + EnterOuterAlt(_localctx, 10); + { + State = 2000; methodReference(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PrimaryNoNewArray_lf_arrayAccessContext : ParserRuleContext { + public PrimaryNoNewArray_lf_arrayAccessContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_primaryNoNewArray_lf_arrayAccess; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPrimaryNoNewArray_lf_arrayAccess(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPrimaryNoNewArray_lf_arrayAccess(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPrimaryNoNewArray_lf_arrayAccess(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess() { + PrimaryNoNewArray_lf_arrayAccessContext _localctx = new PrimaryNoNewArray_lf_arrayAccessContext(Context, State); + EnterRule(_localctx, 368, RULE_primaryNoNewArray_lf_arrayAccess); + try { + EnterOuterAlt(_localctx, 1); + { + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PrimaryNoNewArray_lfno_arrayAccessContext : ParserRuleContext { + public LiteralContext literal() { + return GetRuleContext(0); + } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ITerminalNode CLASS() { return GetToken(Java9Parser.CLASS, 0); } + public ITerminalNode[] LBRACK() { return GetTokens(Java9Parser.LBRACK); } + public ITerminalNode LBRACK(int i) { + return GetToken(Java9Parser.LBRACK, i); + } + public ITerminalNode[] RBRACK() { return GetTokens(Java9Parser.RBRACK); } + public ITerminalNode RBRACK(int i) { + return GetToken(Java9Parser.RBRACK, i); + } + public ITerminalNode VOID() { return GetToken(Java9Parser.VOID, 0); } + public ITerminalNode THIS() { return GetToken(Java9Parser.THIS, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { + return GetRuleContext(0); + } + public FieldAccessContext fieldAccess() { + return GetRuleContext(0); + } + public MethodInvocationContext methodInvocation() { + return GetRuleContext(0); + } + public MethodReferenceContext methodReference() { + return GetRuleContext(0); + } + public PrimaryNoNewArray_lfno_arrayAccessContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_primaryNoNewArray_lfno_arrayAccess; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPrimaryNoNewArray_lfno_arrayAccess(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPrimaryNoNewArray_lfno_arrayAccess(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPrimaryNoNewArray_lfno_arrayAccess(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() { + PrimaryNoNewArray_lfno_arrayAccessContext _localctx = new PrimaryNoNewArray_lfno_arrayAccessContext(Context, State); + EnterRule(_localctx, 370, RULE_primaryNoNewArray_lfno_arrayAccess); + int _la; + try { + State = 2033; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,208,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2005; literal(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2006; typeName(); + State = 2011; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==LBRACK) { + { + { + State = 2007; Match(LBRACK); + State = 2008; Match(RBRACK); + } + } + State = 2013; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2014; Match(DOT); + State = 2015; Match(CLASS); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2017; Match(VOID); + State = 2018; Match(DOT); + State = 2019; Match(CLASS); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 2020; Match(THIS); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 2021; typeName(); + State = 2022; Match(DOT); + State = 2023; Match(THIS); + } + break; + case 6: + EnterOuterAlt(_localctx, 6); + { + State = 2025; Match(LPAREN); + State = 2026; expression(); + State = 2027; Match(RPAREN); + } + break; + case 7: + EnterOuterAlt(_localctx, 7); + { + State = 2029; classInstanceCreationExpression(); + } + break; + case 8: + EnterOuterAlt(_localctx, 8); + { + State = 2030; fieldAccess(); + } + break; + case 9: + EnterOuterAlt(_localctx, 9); + { + State = 2031; methodInvocation(); + } + break; + case 10: + EnterOuterAlt(_localctx, 10); + { + State = 2032; methodReference(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PrimaryNoNewArray_lf_primaryContext : ParserRuleContext { + public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() { + return GetRuleContext(0); + } + public FieldAccess_lf_primaryContext fieldAccess_lf_primary() { + return GetRuleContext(0); + } + public ArrayAccess_lf_primaryContext arrayAccess_lf_primary() { + return GetRuleContext(0); + } + public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() { + return GetRuleContext(0); + } + public MethodReference_lf_primaryContext methodReference_lf_primary() { + return GetRuleContext(0); + } + public PrimaryNoNewArray_lf_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_primaryNoNewArray_lf_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPrimaryNoNewArray_lf_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPrimaryNoNewArray_lf_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPrimaryNoNewArray_lf_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary() { + PrimaryNoNewArray_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primaryContext(Context, State); + EnterRule(_localctx, 372, RULE_primaryNoNewArray_lf_primary); + try { + State = 2040; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,209,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2035; classInstanceCreationExpression_lf_primary(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2036; fieldAccess_lf_primary(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2037; arrayAccess_lf_primary(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 2038; methodInvocation_lf_primary(); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 2039; methodReference_lf_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext : ParserRuleContext { + public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() { + PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(Context, State); + EnterRule(_localctx, 374, RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary); + try { + EnterOuterAlt(_localctx, 1); + { + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext : ParserRuleContext { + public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() { + return GetRuleContext(0); + } + public FieldAccess_lf_primaryContext fieldAccess_lf_primary() { + return GetRuleContext(0); + } + public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() { + return GetRuleContext(0); + } + public MethodReference_lf_primaryContext methodReference_lf_primary() { + return GetRuleContext(0); + } + public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() { + PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(Context, State); + EnterRule(_localctx, 376, RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary); + try { + State = 2048; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,210,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2044; classInstanceCreationExpression_lf_primary(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2045; fieldAccess_lf_primary(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2046; methodInvocation_lf_primary(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 2047; methodReference_lf_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PrimaryNoNewArray_lfno_primaryContext : ParserRuleContext { + public LiteralContext literal() { + return GetRuleContext(0); + } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ITerminalNode CLASS() { return GetToken(Java9Parser.CLASS, 0); } + public ITerminalNode[] LBRACK() { return GetTokens(Java9Parser.LBRACK); } + public ITerminalNode LBRACK(int i) { + return GetToken(Java9Parser.LBRACK, i); + } + public ITerminalNode[] RBRACK() { return GetTokens(Java9Parser.RBRACK); } + public ITerminalNode RBRACK(int i) { + return GetToken(Java9Parser.RBRACK, i); + } + public UnannPrimitiveTypeContext unannPrimitiveType() { + return GetRuleContext(0); + } + public ITerminalNode VOID() { return GetToken(Java9Parser.VOID, 0); } + public ITerminalNode THIS() { return GetToken(Java9Parser.THIS, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() { + return GetRuleContext(0); + } + public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() { + return GetRuleContext(0); + } + public ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() { + return GetRuleContext(0); + } + public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() { + return GetRuleContext(0); + } + public MethodReference_lfno_primaryContext methodReference_lfno_primary() { + return GetRuleContext(0); + } + public PrimaryNoNewArray_lfno_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_primaryNoNewArray_lfno_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPrimaryNoNewArray_lfno_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPrimaryNoNewArray_lfno_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPrimaryNoNewArray_lfno_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() { + PrimaryNoNewArray_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primaryContext(Context, State); + EnterRule(_localctx, 378, RULE_primaryNoNewArray_lfno_primary); + int _la; + try { + State = 2090; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,213,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2050; literal(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2051; typeName(); + State = 2056; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==LBRACK) { + { + { + State = 2052; Match(LBRACK); + State = 2053; Match(RBRACK); + } + } + State = 2058; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2059; Match(DOT); + State = 2060; Match(CLASS); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2062; unannPrimitiveType(); + State = 2067; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==LBRACK) { + { + { + State = 2063; Match(LBRACK); + State = 2064; Match(RBRACK); + } + } + State = 2069; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2070; Match(DOT); + State = 2071; Match(CLASS); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 2073; Match(VOID); + State = 2074; Match(DOT); + State = 2075; Match(CLASS); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 2076; Match(THIS); + } + break; + case 6: + EnterOuterAlt(_localctx, 6); + { + State = 2077; typeName(); + State = 2078; Match(DOT); + State = 2079; Match(THIS); + } + break; + case 7: + EnterOuterAlt(_localctx, 7); + { + State = 2081; Match(LPAREN); + State = 2082; expression(); + State = 2083; Match(RPAREN); + } + break; + case 8: + EnterOuterAlt(_localctx, 8); + { + State = 2085; classInstanceCreationExpression_lfno_primary(); + } + break; + case 9: + EnterOuterAlt(_localctx, 9); + { + State = 2086; fieldAccess_lfno_primary(); + } + break; + case 10: + EnterOuterAlt(_localctx, 10); + { + State = 2087; arrayAccess_lfno_primary(); + } + break; + case 11: + EnterOuterAlt(_localctx, 11); + { + State = 2088; methodInvocation_lfno_primary(); + } + break; + case 12: + EnterOuterAlt(_localctx, 12); + { + State = 2089; methodReference_lfno_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext : ParserRuleContext { + public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() { + PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(Context, State); + EnterRule(_localctx, 380, RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary); + try { + EnterOuterAlt(_localctx, 1); + { + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext : ParserRuleContext { + public LiteralContext literal() { + return GetRuleContext(0); + } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ITerminalNode CLASS() { return GetToken(Java9Parser.CLASS, 0); } + public ITerminalNode[] LBRACK() { return GetTokens(Java9Parser.LBRACK); } + public ITerminalNode LBRACK(int i) { + return GetToken(Java9Parser.LBRACK, i); + } + public ITerminalNode[] RBRACK() { return GetTokens(Java9Parser.RBRACK); } + public ITerminalNode RBRACK(int i) { + return GetToken(Java9Parser.RBRACK, i); + } + public UnannPrimitiveTypeContext unannPrimitiveType() { + return GetRuleContext(0); + } + public ITerminalNode VOID() { return GetToken(Java9Parser.VOID, 0); } + public ITerminalNode THIS() { return GetToken(Java9Parser.THIS, 0); } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() { + return GetRuleContext(0); + } + public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() { + return GetRuleContext(0); + } + public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() { + return GetRuleContext(0); + } + public MethodReference_lfno_primaryContext methodReference_lfno_primary() { + return GetRuleContext(0); + } + public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() { + PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(Context, State); + EnterRule(_localctx, 382, RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary); + int _la; + try { + State = 2133; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,216,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2094; literal(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2095; typeName(); + State = 2100; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==LBRACK) { + { + { + State = 2096; Match(LBRACK); + State = 2097; Match(RBRACK); + } + } + State = 2102; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2103; Match(DOT); + State = 2104; Match(CLASS); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2106; unannPrimitiveType(); + State = 2111; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==LBRACK) { + { + { + State = 2107; Match(LBRACK); + State = 2108; Match(RBRACK); + } + } + State = 2113; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2114; Match(DOT); + State = 2115; Match(CLASS); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 2117; Match(VOID); + State = 2118; Match(DOT); + State = 2119; Match(CLASS); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 2120; Match(THIS); + } + break; + case 6: + EnterOuterAlt(_localctx, 6); + { + State = 2121; typeName(); + State = 2122; Match(DOT); + State = 2123; Match(THIS); + } + break; + case 7: + EnterOuterAlt(_localctx, 7); + { + State = 2125; Match(LPAREN); + State = 2126; expression(); + State = 2127; Match(RPAREN); + } + break; + case 8: + EnterOuterAlt(_localctx, 8); + { + State = 2129; classInstanceCreationExpression_lfno_primary(); + } + break; + case 9: + EnterOuterAlt(_localctx, 9); + { + State = 2130; fieldAccess_lfno_primary(); + } + break; + case 10: + EnterOuterAlt(_localctx, 10); + { + State = 2131; methodInvocation_lfno_primary(); + } + break; + case 11: + EnterOuterAlt(_localctx, 11); + { + State = 2132; methodReference_lfno_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassLiteralContext : ParserRuleContext { + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ITerminalNode CLASS() { return GetToken(Java9Parser.CLASS, 0); } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public NumericTypeContext numericType() { + return GetRuleContext(0); + } + public ITerminalNode BOOLEAN() { return GetToken(Java9Parser.BOOLEAN, 0); } + public ITerminalNode[] LBRACK() { return GetTokens(Java9Parser.LBRACK); } + public ITerminalNode LBRACK(int i) { + return GetToken(Java9Parser.LBRACK, i); + } + public ITerminalNode[] RBRACK() { return GetTokens(Java9Parser.RBRACK); } + public ITerminalNode RBRACK(int i) { + return GetToken(Java9Parser.RBRACK, i); + } + public ITerminalNode VOID() { return GetToken(Java9Parser.VOID, 0); } + public ClassLiteralContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classLiteral; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassLiteral(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassLiteral(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassLiteral(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassLiteralContext classLiteral() { + ClassLiteralContext _localctx = new ClassLiteralContext(Context, State); + EnterRule(_localctx, 384, RULE_classLiteral); + int _la; + try { + State = 2152; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case EXPORTS: + case FLOAT: + case INT: + case LONG: + case MODULE: + case OPEN: + case OPENS: + case PROVIDES: + case REQUIRES: + case SHORT: + case TO: + case USES: + case WITH: + case Identifier: + EnterOuterAlt(_localctx, 1); + { + State = 2138; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case EXPORTS: + case MODULE: + case OPEN: + case OPENS: + case PROVIDES: + case REQUIRES: + case TO: + case USES: + case WITH: + case Identifier: + { + State = 2135; typeName(); + } + break; + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + { + State = 2136; numericType(); + } + break; + case BOOLEAN: + { + State = 2137; Match(BOOLEAN); + } + break; + default: + throw new NoViableAltException(this); + } + State = 2144; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==LBRACK) { + { + { + State = 2140; Match(LBRACK); + State = 2141; Match(RBRACK); + } + } + State = 2146; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2147; Match(DOT); + State = 2148; Match(CLASS); + } + break; + case VOID: + EnterOuterAlt(_localctx, 2); + { + State = 2149; Match(VOID); + State = 2150; Match(DOT); + State = 2151; Match(CLASS); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassInstanceCreationExpressionContext : ParserRuleContext { + public ITerminalNode NEW() { return GetToken(Java9Parser.NEW, 0); } + public IdentifierContext[] identifier() { + return GetRuleContexts(); + } + public IdentifierContext identifier(int i) { + return GetRuleContext(i); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] DOT() { return GetTokens(Java9Parser.DOT); } + public ITerminalNode DOT(int i) { + return GetToken(Java9Parser.DOT, i); + } + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { + return GetRuleContext(0); + } + public ArgumentListContext argumentList() { + return GetRuleContext(0); + } + public ClassBodyContext classBody() { + return GetRuleContext(0); + } + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public PrimaryContext primary() { + return GetRuleContext(0); + } + public ClassInstanceCreationExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classInstanceCreationExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassInstanceCreationExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassInstanceCreationExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassInstanceCreationExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { + ClassInstanceCreationExpressionContext _localctx = new ClassInstanceCreationExpressionContext(Context, State); + EnterRule(_localctx, 386, RULE_classInstanceCreationExpression); + int _la; + try { + State = 2237; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,237,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2154; Match(NEW); + State = 2156; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2155; typeArguments(); + } + } + + State = 2161; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 2158; annotation(); + } + } + State = 2163; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2164; identifier(); + State = 2175; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==DOT) { + { + { + State = 2165; Match(DOT); + State = 2169; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 2166; annotation(); + } + } + State = 2171; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2172; identifier(); + } + } + State = 2177; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2179; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2178; typeArgumentsOrDiamond(); + } + } + + State = 2181; Match(LPAREN); + State = 2183; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2182; argumentList(); + } + } + + State = 2185; Match(RPAREN); + State = 2187; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LBRACE) { + { + State = 2186; classBody(); + } + } + + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2189; expressionName(); + State = 2190; Match(DOT); + State = 2191; Match(NEW); + State = 2193; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2192; typeArguments(); + } + } + + State = 2198; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 2195; annotation(); + } + } + State = 2200; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2201; identifier(); + State = 2203; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2202; typeArgumentsOrDiamond(); + } + } + + State = 2205; Match(LPAREN); + State = 2207; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2206; argumentList(); + } + } + + State = 2209; Match(RPAREN); + State = 2211; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LBRACE) { + { + State = 2210; classBody(); + } + } + + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2213; primary(); + State = 2214; Match(DOT); + State = 2215; Match(NEW); + State = 2217; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2216; typeArguments(); + } + } + + State = 2222; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 2219; annotation(); + } + } + State = 2224; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2225; identifier(); + State = 2227; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2226; typeArgumentsOrDiamond(); + } + } + + State = 2229; Match(LPAREN); + State = 2231; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2230; argumentList(); + } + } + + State = 2233; Match(RPAREN); + State = 2235; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LBRACE) { + { + State = 2234; classBody(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassInstanceCreationExpression_lf_primaryContext : ParserRuleContext { + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ITerminalNode NEW() { return GetToken(Java9Parser.NEW, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { + return GetRuleContext(0); + } + public ArgumentListContext argumentList() { + return GetRuleContext(0); + } + public ClassBodyContext classBody() { + return GetRuleContext(0); + } + public ClassInstanceCreationExpression_lf_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classInstanceCreationExpression_lf_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassInstanceCreationExpression_lf_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassInstanceCreationExpression_lf_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassInstanceCreationExpression_lf_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() { + ClassInstanceCreationExpression_lf_primaryContext _localctx = new ClassInstanceCreationExpression_lf_primaryContext(Context, State); + EnterRule(_localctx, 388, RULE_classInstanceCreationExpression_lf_primary); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 2239; Match(DOT); + State = 2240; Match(NEW); + State = 2242; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2241; typeArguments(); + } + } + + State = 2247; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 2244; annotation(); + } + } + State = 2249; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2250; identifier(); + State = 2252; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2251; typeArgumentsOrDiamond(); + } + } + + State = 2254; Match(LPAREN); + State = 2256; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2255; argumentList(); + } + } + + State = 2258; Match(RPAREN); + State = 2260; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,242,Context) ) { + case 1: + { + State = 2259; classBody(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ClassInstanceCreationExpression_lfno_primaryContext : ParserRuleContext { + public ITerminalNode NEW() { return GetToken(Java9Parser.NEW, 0); } + public IdentifierContext[] identifier() { + return GetRuleContexts(); + } + public IdentifierContext identifier(int i) { + return GetRuleContext(i); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] DOT() { return GetTokens(Java9Parser.DOT); } + public ITerminalNode DOT(int i) { + return GetToken(Java9Parser.DOT, i); + } + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { + return GetRuleContext(0); + } + public ArgumentListContext argumentList() { + return GetRuleContext(0); + } + public ClassBodyContext classBody() { + return GetRuleContext(0); + } + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public ClassInstanceCreationExpression_lfno_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_classInstanceCreationExpression_lfno_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterClassInstanceCreationExpression_lfno_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitClassInstanceCreationExpression_lfno_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitClassInstanceCreationExpression_lfno_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() { + ClassInstanceCreationExpression_lfno_primaryContext _localctx = new ClassInstanceCreationExpression_lfno_primaryContext(Context, State); + EnterRule(_localctx, 390, RULE_classInstanceCreationExpression_lfno_primary); + int _la; + try { + State = 2321; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case NEW: + EnterOuterAlt(_localctx, 1); + { + State = 2262; Match(NEW); + State = 2264; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2263; typeArguments(); + } + } + + State = 2269; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 2266; annotation(); + } + } + State = 2271; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2272; identifier(); + State = 2283; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==DOT) { + { + { + State = 2273; Match(DOT); + State = 2277; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 2274; annotation(); + } + } + State = 2279; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2280; identifier(); + } + } + State = 2285; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2287; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2286; typeArgumentsOrDiamond(); + } + } + + State = 2289; Match(LPAREN); + State = 2291; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2290; argumentList(); + } + } + + State = 2293; Match(RPAREN); + State = 2295; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,249,Context) ) { + case 1: + { + State = 2294; classBody(); + } + break; + } + } + break; + case EXPORTS: + case MODULE: + case OPEN: + case OPENS: + case PROVIDES: + case REQUIRES: + case TO: + case USES: + case WITH: + case Identifier: + EnterOuterAlt(_localctx, 2); + { + State = 2297; expressionName(); + State = 2298; Match(DOT); + State = 2299; Match(NEW); + State = 2301; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2300; typeArguments(); + } + } + + State = 2306; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 2303; annotation(); + } + } + State = 2308; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2309; identifier(); + State = 2311; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2310; typeArgumentsOrDiamond(); + } + } + + State = 2313; Match(LPAREN); + State = 2315; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2314; argumentList(); + } + } + + State = 2317; Match(RPAREN); + State = 2319; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,254,Context) ) { + case 1: + { + State = 2318; classBody(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class TypeArgumentsOrDiamondContext : ParserRuleContext { + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public ITerminalNode LT() { return GetToken(Java9Parser.LT, 0); } + public ITerminalNode GT() { return GetToken(Java9Parser.GT, 0); } + public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_typeArgumentsOrDiamond; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterTypeArgumentsOrDiamond(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitTypeArgumentsOrDiamond(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitTypeArgumentsOrDiamond(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { + TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(Context, State); + EnterRule(_localctx, 392, RULE_typeArgumentsOrDiamond); + try { + State = 2326; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,256,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2323; typeArguments(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2324; Match(LT); + State = 2325; Match(GT); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class FieldAccessContext : ParserRuleContext { + public PrimaryContext primary() { + return GetRuleContext(0); + } + public ITerminalNode[] DOT() { return GetTokens(Java9Parser.DOT); } + public ITerminalNode DOT(int i) { + return GetToken(Java9Parser.DOT, i); + } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ITerminalNode SUPER() { return GetToken(Java9Parser.SUPER, 0); } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public FieldAccessContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_fieldAccess; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterFieldAccess(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitFieldAccess(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitFieldAccess(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public FieldAccessContext fieldAccess() { + FieldAccessContext _localctx = new FieldAccessContext(Context, State); + EnterRule(_localctx, 394, RULE_fieldAccess); + try { + State = 2341; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,257,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2328; primary(); + State = 2329; Match(DOT); + State = 2330; identifier(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2332; Match(SUPER); + State = 2333; Match(DOT); + State = 2334; identifier(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2335; typeName(); + State = 2336; Match(DOT); + State = 2337; Match(SUPER); + State = 2338; Match(DOT); + State = 2339; identifier(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class FieldAccess_lf_primaryContext : ParserRuleContext { + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public FieldAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_fieldAccess_lf_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterFieldAccess_lf_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitFieldAccess_lf_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitFieldAccess_lf_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public FieldAccess_lf_primaryContext fieldAccess_lf_primary() { + FieldAccess_lf_primaryContext _localctx = new FieldAccess_lf_primaryContext(Context, State); + EnterRule(_localctx, 396, RULE_fieldAccess_lf_primary); + try { + EnterOuterAlt(_localctx, 1); + { + State = 2343; Match(DOT); + State = 2344; identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class FieldAccess_lfno_primaryContext : ParserRuleContext { + public ITerminalNode SUPER() { return GetToken(Java9Parser.SUPER, 0); } + public ITerminalNode[] DOT() { return GetTokens(Java9Parser.DOT); } + public ITerminalNode DOT(int i) { + return GetToken(Java9Parser.DOT, i); + } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public FieldAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_fieldAccess_lfno_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterFieldAccess_lfno_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitFieldAccess_lfno_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitFieldAccess_lfno_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() { + FieldAccess_lfno_primaryContext _localctx = new FieldAccess_lfno_primaryContext(Context, State); + EnterRule(_localctx, 398, RULE_fieldAccess_lfno_primary); + try { + State = 2355; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case SUPER: + EnterOuterAlt(_localctx, 1); + { + State = 2346; Match(SUPER); + State = 2347; Match(DOT); + State = 2348; identifier(); + } + break; + case EXPORTS: + case MODULE: + case OPEN: + case OPENS: + case PROVIDES: + case REQUIRES: + case TO: + case USES: + case WITH: + case Identifier: + EnterOuterAlt(_localctx, 2); + { + State = 2349; typeName(); + State = 2350; Match(DOT); + State = 2351; Match(SUPER); + State = 2352; Match(DOT); + State = 2353; identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ArrayAccessContext : ParserRuleContext { + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public ITerminalNode[] LBRACK() { return GetTokens(Java9Parser.LBRACK); } + public ITerminalNode LBRACK(int i) { + return GetToken(Java9Parser.LBRACK, i); + } + public ExpressionContext[] expression() { + return GetRuleContexts(); + } + public ExpressionContext expression(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] RBRACK() { return GetTokens(Java9Parser.RBRACK); } + public ITerminalNode RBRACK(int i) { + return GetToken(Java9Parser.RBRACK, i); + } + public PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() { + return GetRuleContext(0); + } + public PrimaryNoNewArray_lf_arrayAccessContext[] primaryNoNewArray_lf_arrayAccess() { + return GetRuleContexts(); + } + public PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess(int i) { + return GetRuleContext(i); + } + public ArrayAccessContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_arrayAccess; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterArrayAccess(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitArrayAccess(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitArrayAccess(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ArrayAccessContext arrayAccess() { + ArrayAccessContext _localctx = new ArrayAccessContext(Context, State); + EnterRule(_localctx, 400, RULE_arrayAccess); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 2367; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,259,Context) ) { + case 1: + { + State = 2357; expressionName(); + State = 2358; Match(LBRACK); + State = 2359; expression(); + State = 2360; Match(RBRACK); + } + break; + case 2: + { + State = 2362; primaryNoNewArray_lfno_arrayAccess(); + State = 2363; Match(LBRACK); + State = 2364; expression(); + State = 2365; Match(RBRACK); + } + break; + } + State = 2376; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==LBRACK) { + { + { + State = 2369; primaryNoNewArray_lf_arrayAccess(); + State = 2370; Match(LBRACK); + State = 2371; expression(); + State = 2372; Match(RBRACK); + } + } + State = 2378; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ArrayAccess_lf_primaryContext : ParserRuleContext { + public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() { + return GetRuleContext(0); + } + public ITerminalNode[] LBRACK() { return GetTokens(Java9Parser.LBRACK); } + public ITerminalNode LBRACK(int i) { + return GetToken(Java9Parser.LBRACK, i); + } + public ExpressionContext[] expression() { + return GetRuleContexts(); + } + public ExpressionContext expression(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] RBRACK() { return GetTokens(Java9Parser.RBRACK); } + public ITerminalNode RBRACK(int i) { + return GetToken(Java9Parser.RBRACK, i); + } + public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext[] primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() { + return GetRuleContexts(); + } + public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(int i) { + return GetRuleContext(i); + } + public ArrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_arrayAccess_lf_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterArrayAccess_lf_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitArrayAccess_lf_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitArrayAccess_lf_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ArrayAccess_lf_primaryContext arrayAccess_lf_primary() { + ArrayAccess_lf_primaryContext _localctx = new ArrayAccess_lf_primaryContext(Context, State); + EnterRule(_localctx, 402, RULE_arrayAccess_lf_primary); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 2379; primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(); + State = 2380; Match(LBRACK); + State = 2381; expression(); + State = 2382; Match(RBRACK); + } + State = 2391; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,261,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 2384; primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(); + State = 2385; Match(LBRACK); + State = 2386; expression(); + State = 2387; Match(RBRACK); + } + } + } + State = 2393; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,261,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ArrayAccess_lfno_primaryContext : ParserRuleContext { + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public ITerminalNode[] LBRACK() { return GetTokens(Java9Parser.LBRACK); } + public ITerminalNode LBRACK(int i) { + return GetToken(Java9Parser.LBRACK, i); + } + public ExpressionContext[] expression() { + return GetRuleContexts(); + } + public ExpressionContext expression(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] RBRACK() { return GetTokens(Java9Parser.RBRACK); } + public ITerminalNode RBRACK(int i) { + return GetToken(Java9Parser.RBRACK, i); + } + public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() { + return GetRuleContext(0); + } + public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext[] primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() { + return GetRuleContexts(); + } + public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(int i) { + return GetRuleContext(i); + } + public ArrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_arrayAccess_lfno_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterArrayAccess_lfno_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitArrayAccess_lfno_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitArrayAccess_lfno_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() { + ArrayAccess_lfno_primaryContext _localctx = new ArrayAccess_lfno_primaryContext(Context, State); + EnterRule(_localctx, 404, RULE_arrayAccess_lfno_primary); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 2404; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,262,Context) ) { + case 1: + { + State = 2394; expressionName(); + State = 2395; Match(LBRACK); + State = 2396; expression(); + State = 2397; Match(RBRACK); + } + break; + case 2: + { + State = 2399; primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(); + State = 2400; Match(LBRACK); + State = 2401; expression(); + State = 2402; Match(RBRACK); + } + break; + } + State = 2413; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,263,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + State = 2406; primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(); + State = 2407; Match(LBRACK); + State = 2408; expression(); + State = 2409; Match(RBRACK); + } + } + } + State = 2415; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,263,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodInvocationContext : ParserRuleContext { + public MethodNameContext methodName() { + return GetRuleContext(0); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ArgumentListContext argumentList() { + return GetRuleContext(0); + } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode[] DOT() { return GetTokens(Java9Parser.DOT); } + public ITerminalNode DOT(int i) { + return GetToken(Java9Parser.DOT, i); + } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public PrimaryContext primary() { + return GetRuleContext(0); + } + public ITerminalNode SUPER() { return GetToken(Java9Parser.SUPER, 0); } + public MethodInvocationContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodInvocation; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodInvocation(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodInvocation(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodInvocation(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodInvocationContext methodInvocation() { + MethodInvocationContext _localctx = new MethodInvocationContext(Context, State); + EnterRule(_localctx, 406, RULE_methodInvocation); + int _la; + try { + State = 2485; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,275,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2416; methodName(); + State = 2417; Match(LPAREN); + State = 2419; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2418; argumentList(); + } + } + + State = 2421; Match(RPAREN); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2423; typeName(); + State = 2424; Match(DOT); + State = 2426; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2425; typeArguments(); + } + } + + State = 2428; identifier(); + State = 2429; Match(LPAREN); + State = 2431; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2430; argumentList(); + } + } + + State = 2433; Match(RPAREN); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2435; expressionName(); + State = 2436; Match(DOT); + State = 2438; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2437; typeArguments(); + } + } + + State = 2440; identifier(); + State = 2441; Match(LPAREN); + State = 2443; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2442; argumentList(); + } + } + + State = 2445; Match(RPAREN); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 2447; primary(); + State = 2448; Match(DOT); + State = 2450; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2449; typeArguments(); + } + } + + State = 2452; identifier(); + State = 2453; Match(LPAREN); + State = 2455; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2454; argumentList(); + } + } + + State = 2457; Match(RPAREN); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 2459; Match(SUPER); + State = 2460; Match(DOT); + State = 2462; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2461; typeArguments(); + } + } + + State = 2464; identifier(); + State = 2465; Match(LPAREN); + State = 2467; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2466; argumentList(); + } + } + + State = 2469; Match(RPAREN); + } + break; + case 6: + EnterOuterAlt(_localctx, 6); + { + State = 2471; typeName(); + State = 2472; Match(DOT); + State = 2473; Match(SUPER); + State = 2474; Match(DOT); + State = 2476; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2475; typeArguments(); + } + } + + State = 2478; identifier(); + State = 2479; Match(LPAREN); + State = 2481; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2480; argumentList(); + } + } + + State = 2483; Match(RPAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodInvocation_lf_primaryContext : ParserRuleContext { + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public ArgumentListContext argumentList() { + return GetRuleContext(0); + } + public MethodInvocation_lf_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodInvocation_lf_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodInvocation_lf_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodInvocation_lf_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodInvocation_lf_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() { + MethodInvocation_lf_primaryContext _localctx = new MethodInvocation_lf_primaryContext(Context, State); + EnterRule(_localctx, 408, RULE_methodInvocation_lf_primary); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 2487; Match(DOT); + State = 2489; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2488; typeArguments(); + } + } + + State = 2491; identifier(); + State = 2492; Match(LPAREN); + State = 2494; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2493; argumentList(); + } + } + + State = 2496; Match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodInvocation_lfno_primaryContext : ParserRuleContext { + public MethodNameContext methodName() { + return GetRuleContext(0); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public ArgumentListContext argumentList() { + return GetRuleContext(0); + } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode[] DOT() { return GetTokens(Java9Parser.DOT); } + public ITerminalNode DOT(int i) { + return GetToken(Java9Parser.DOT, i); + } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public ITerminalNode SUPER() { return GetToken(Java9Parser.SUPER, 0); } + public MethodInvocation_lfno_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodInvocation_lfno_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodInvocation_lfno_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodInvocation_lfno_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodInvocation_lfno_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() { + MethodInvocation_lfno_primaryContext _localctx = new MethodInvocation_lfno_primaryContext(Context, State); + EnterRule(_localctx, 410, RULE_methodInvocation_lfno_primary); + int _la; + try { + State = 2555; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,287,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2498; methodName(); + State = 2499; Match(LPAREN); + State = 2501; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2500; argumentList(); + } + } + + State = 2503; Match(RPAREN); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2505; typeName(); + State = 2506; Match(DOT); + State = 2508; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2507; typeArguments(); + } + } + + State = 2510; identifier(); + State = 2511; Match(LPAREN); + State = 2513; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2512; argumentList(); + } + } + + State = 2515; Match(RPAREN); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2517; expressionName(); + State = 2518; Match(DOT); + State = 2520; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2519; typeArguments(); + } + } + + State = 2522; identifier(); + State = 2523; Match(LPAREN); + State = 2525; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2524; argumentList(); + } + } + + State = 2527; Match(RPAREN); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 2529; Match(SUPER); + State = 2530; Match(DOT); + State = 2532; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2531; typeArguments(); + } + } + + State = 2534; identifier(); + State = 2535; Match(LPAREN); + State = 2537; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2536; argumentList(); + } + } + + State = 2539; Match(RPAREN); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 2541; typeName(); + State = 2542; Match(DOT); + State = 2543; Match(SUPER); + State = 2544; Match(DOT); + State = 2546; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2545; typeArguments(); + } + } + + State = 2548; identifier(); + State = 2549; Match(LPAREN); + State = 2551; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << NEW) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << TO) | (1L << USES) | (1L << VOID) | (1L << WITH) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) { + { + State = 2550; argumentList(); + } + } + + State = 2553; Match(RPAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ArgumentListContext : ParserRuleContext { + public ExpressionContext[] expression() { + return GetRuleContexts(); + } + public ExpressionContext expression(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public ArgumentListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_argumentList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterArgumentList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitArgumentList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitArgumentList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ArgumentListContext argumentList() { + ArgumentListContext _localctx = new ArgumentListContext(Context, State); + EnterRule(_localctx, 412, RULE_argumentList); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 2557; expression(); + State = 2562; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 2558; Match(COMMA); + State = 2559; expression(); + } + } + State = 2564; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodReferenceContext : ParserRuleContext { + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public ITerminalNode COLONCOLON() { return GetToken(Java9Parser.COLONCOLON, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public ReferenceTypeContext referenceType() { + return GetRuleContext(0); + } + public PrimaryContext primary() { + return GetRuleContext(0); + } + public ITerminalNode SUPER() { return GetToken(Java9Parser.SUPER, 0); } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ClassTypeContext classType() { + return GetRuleContext(0); + } + public ITerminalNode NEW() { return GetToken(Java9Parser.NEW, 0); } + public ArrayTypeContext arrayType() { + return GetRuleContext(0); + } + public MethodReferenceContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodReference; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodReference(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodReference(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodReference(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodReferenceContext methodReference() { + MethodReferenceContext _localctx = new MethodReferenceContext(Context, State); + EnterRule(_localctx, 414, RULE_methodReference); + int _la; + try { + State = 2612; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,295,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2565; expressionName(); + State = 2566; Match(COLONCOLON); + State = 2568; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2567; typeArguments(); + } + } + + State = 2570; identifier(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2572; referenceType(); + State = 2573; Match(COLONCOLON); + State = 2575; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2574; typeArguments(); + } + } + + State = 2577; identifier(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2579; primary(); + State = 2580; Match(COLONCOLON); + State = 2582; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2581; typeArguments(); + } + } + + State = 2584; identifier(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 2586; Match(SUPER); + State = 2587; Match(COLONCOLON); + State = 2589; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2588; typeArguments(); + } + } + + State = 2591; identifier(); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 2592; typeName(); + State = 2593; Match(DOT); + State = 2594; Match(SUPER); + State = 2595; Match(COLONCOLON); + State = 2597; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2596; typeArguments(); + } + } + + State = 2599; identifier(); + } + break; + case 6: + EnterOuterAlt(_localctx, 6); + { + State = 2601; classType(); + State = 2602; Match(COLONCOLON); + State = 2604; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2603; typeArguments(); + } + } + + State = 2606; Match(NEW); + } + break; + case 7: + EnterOuterAlt(_localctx, 7); + { + State = 2608; arrayType(); + State = 2609; Match(COLONCOLON); + State = 2610; Match(NEW); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodReference_lf_primaryContext : ParserRuleContext { + public ITerminalNode COLONCOLON() { return GetToken(Java9Parser.COLONCOLON, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public MethodReference_lf_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodReference_lf_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodReference_lf_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodReference_lf_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodReference_lf_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodReference_lf_primaryContext methodReference_lf_primary() { + MethodReference_lf_primaryContext _localctx = new MethodReference_lf_primaryContext(Context, State); + EnterRule(_localctx, 416, RULE_methodReference_lf_primary); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 2614; Match(COLONCOLON); + State = 2616; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2615; typeArguments(); + } + } + + State = 2618; identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodReference_lfno_primaryContext : ParserRuleContext { + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public ITerminalNode COLONCOLON() { return GetToken(Java9Parser.COLONCOLON, 0); } + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public TypeArgumentsContext typeArguments() { + return GetRuleContext(0); + } + public ReferenceTypeContext referenceType() { + return GetRuleContext(0); + } + public ITerminalNode SUPER() { return GetToken(Java9Parser.SUPER, 0); } + public TypeNameContext typeName() { + return GetRuleContext(0); + } + public ITerminalNode DOT() { return GetToken(Java9Parser.DOT, 0); } + public ClassTypeContext classType() { + return GetRuleContext(0); + } + public ITerminalNode NEW() { return GetToken(Java9Parser.NEW, 0); } + public ArrayTypeContext arrayType() { + return GetRuleContext(0); + } + public MethodReference_lfno_primaryContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodReference_lfno_primary; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMethodReference_lfno_primary(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMethodReference_lfno_primary(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodReference_lfno_primary(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodReference_lfno_primaryContext methodReference_lfno_primary() { + MethodReference_lfno_primaryContext _localctx = new MethodReference_lfno_primaryContext(Context, State); + EnterRule(_localctx, 418, RULE_methodReference_lfno_primary); + int _la; + try { + State = 2660; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,302,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2620; expressionName(); + State = 2621; Match(COLONCOLON); + State = 2623; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2622; typeArguments(); + } + } + + State = 2625; identifier(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2627; referenceType(); + State = 2628; Match(COLONCOLON); + State = 2630; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2629; typeArguments(); + } + } + + State = 2632; identifier(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2634; Match(SUPER); + State = 2635; Match(COLONCOLON); + State = 2637; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2636; typeArguments(); + } + } + + State = 2639; identifier(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 2640; typeName(); + State = 2641; Match(DOT); + State = 2642; Match(SUPER); + State = 2643; Match(COLONCOLON); + State = 2645; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2644; typeArguments(); + } + } + + State = 2647; identifier(); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 2649; classType(); + State = 2650; Match(COLONCOLON); + State = 2652; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==LT) { + { + State = 2651; typeArguments(); + } + } + + State = 2654; Match(NEW); + } + break; + case 6: + EnterOuterAlt(_localctx, 6); + { + State = 2656; arrayType(); + State = 2657; Match(COLONCOLON); + State = 2658; Match(NEW); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ArrayCreationExpressionContext : ParserRuleContext { + public ITerminalNode NEW() { return GetToken(Java9Parser.NEW, 0); } + public PrimitiveTypeContext primitiveType() { + return GetRuleContext(0); + } + public DimExprsContext dimExprs() { + return GetRuleContext(0); + } + public DimsContext dims() { + return GetRuleContext(0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return GetRuleContext(0); + } + public ArrayInitializerContext arrayInitializer() { + return GetRuleContext(0); + } + public ArrayCreationExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_arrayCreationExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterArrayCreationExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitArrayCreationExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitArrayCreationExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ArrayCreationExpressionContext arrayCreationExpression() { + ArrayCreationExpressionContext _localctx = new ArrayCreationExpressionContext(Context, State); + EnterRule(_localctx, 420, RULE_arrayCreationExpression); + try { + State = 2684; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,305,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2662; Match(NEW); + State = 2663; primitiveType(); + State = 2664; dimExprs(); + State = 2666; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,303,Context) ) { + case 1: + { + State = 2665; dims(); + } + break; + } + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2668; Match(NEW); + State = 2669; classOrInterfaceType(); + State = 2670; dimExprs(); + State = 2672; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,304,Context) ) { + case 1: + { + State = 2671; dims(); + } + break; + } + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2674; Match(NEW); + State = 2675; primitiveType(); + State = 2676; dims(); + State = 2677; arrayInitializer(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 2679; Match(NEW); + State = 2680; classOrInterfaceType(); + State = 2681; dims(); + State = 2682; arrayInitializer(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class DimExprsContext : ParserRuleContext { + public DimExprContext[] dimExpr() { + return GetRuleContexts(); + } + public DimExprContext dimExpr(int i) { + return GetRuleContext(i); + } + public DimExprsContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_dimExprs; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterDimExprs(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitDimExprs(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitDimExprs(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public DimExprsContext dimExprs() { + DimExprsContext _localctx = new DimExprsContext(Context, State); + EnterRule(_localctx, 422, RULE_dimExprs); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 2687; + ErrorHandler.Sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + State = 2686; dimExpr(); + } + } + break; + default: + throw new NoViableAltException(this); + } + State = 2689; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,306,Context); + } while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class DimExprContext : ParserRuleContext { + public ITerminalNode LBRACK() { return GetToken(Java9Parser.LBRACK, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode RBRACK() { return GetToken(Java9Parser.RBRACK, 0); } + public AnnotationContext[] annotation() { + return GetRuleContexts(); + } + public AnnotationContext annotation(int i) { + return GetRuleContext(i); + } + public DimExprContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_dimExpr; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterDimExpr(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitDimExpr(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitDimExpr(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public DimExprContext dimExpr() { + DimExprContext _localctx = new DimExprContext(Context, State); + EnterRule(_localctx, 424, RULE_dimExpr); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 2694; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==AT) { + { + { + State = 2691; annotation(); + } + } + State = 2696; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2697; Match(LBRACK); + State = 2698; expression(); + State = 2699; Match(RBRACK); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ConstantExpressionContext : ParserRuleContext { + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ConstantExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_constantExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterConstantExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitConstantExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitConstantExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ConstantExpressionContext constantExpression() { + ConstantExpressionContext _localctx = new ConstantExpressionContext(Context, State); + EnterRule(_localctx, 426, RULE_constantExpression); + try { + EnterOuterAlt(_localctx, 1); + { + State = 2701; expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ExpressionContext : ParserRuleContext { + public LambdaExpressionContext lambdaExpression() { + return GetRuleContext(0); + } + public AssignmentExpressionContext assignmentExpression() { + return GetRuleContext(0); + } + public ExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_expression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ExpressionContext expression() { + ExpressionContext _localctx = new ExpressionContext(Context, State); + EnterRule(_localctx, 428, RULE_expression); + try { + State = 2705; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,308,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2703; lambdaExpression(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2704; assignmentExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class LambdaExpressionContext : ParserRuleContext { + public LambdaParametersContext lambdaParameters() { + return GetRuleContext(0); + } + public ITerminalNode ARROW() { return GetToken(Java9Parser.ARROW, 0); } + public LambdaBodyContext lambdaBody() { + return GetRuleContext(0); + } + public LambdaExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_lambdaExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterLambdaExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitLambdaExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitLambdaExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public LambdaExpressionContext lambdaExpression() { + LambdaExpressionContext _localctx = new LambdaExpressionContext(Context, State); + EnterRule(_localctx, 430, RULE_lambdaExpression); + try { + EnterOuterAlt(_localctx, 1); + { + State = 2707; lambdaParameters(); + State = 2708; Match(ARROW); + State = 2709; lambdaBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class LambdaParametersContext : ParserRuleContext { + public IdentifierContext identifier() { + return GetRuleContext(0); + } + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public FormalParameterListContext formalParameterList() { + return GetRuleContext(0); + } + public InferredFormalParameterListContext inferredFormalParameterList() { + return GetRuleContext(0); + } + public LambdaParametersContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_lambdaParameters; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterLambdaParameters(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitLambdaParameters(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitLambdaParameters(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public LambdaParametersContext lambdaParameters() { + LambdaParametersContext _localctx = new LambdaParametersContext(Context, State); + EnterRule(_localctx, 432, RULE_lambdaParameters); + int _la; + try { + State = 2721; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,310,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2711; identifier(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2712; Match(LPAREN); + State = 2714; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << EXPORTS) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << MODULE) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << SHORT) | (1L << TO) | (1L << USES) | (1L << WITH))) != 0) || _la==AT || _la==Identifier) { + { + State = 2713; formalParameterList(); + } + } + + State = 2716; Match(RPAREN); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2717; Match(LPAREN); + State = 2718; inferredFormalParameterList(); + State = 2719; Match(RPAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class InferredFormalParameterListContext : ParserRuleContext { + public IdentifierContext[] identifier() { + return GetRuleContexts(); + } + public IdentifierContext identifier(int i) { + return GetRuleContext(i); + } + public ITerminalNode[] COMMA() { return GetTokens(Java9Parser.COMMA); } + public ITerminalNode COMMA(int i) { + return GetToken(Java9Parser.COMMA, i); + } + public InferredFormalParameterListContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_inferredFormalParameterList; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInferredFormalParameterList(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInferredFormalParameterList(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInferredFormalParameterList(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InferredFormalParameterListContext inferredFormalParameterList() { + InferredFormalParameterListContext _localctx = new InferredFormalParameterListContext(Context, State); + EnterRule(_localctx, 434, RULE_inferredFormalParameterList); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 2723; identifier(); + State = 2728; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==COMMA) { + { + { + State = 2724; Match(COMMA); + State = 2725; identifier(); + } + } + State = 2730; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class LambdaBodyContext : ParserRuleContext { + public ExpressionContext expression() { + return GetRuleContext(0); + } + public BlockContext block() { + return GetRuleContext(0); + } + public LambdaBodyContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_lambdaBody; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterLambdaBody(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitLambdaBody(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitLambdaBody(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public LambdaBodyContext lambdaBody() { + LambdaBodyContext _localctx = new LambdaBodyContext(Context, State); + EnterRule(_localctx, 436, RULE_lambdaBody); + try { + State = 2733; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case EXPORTS: + case FLOAT: + case INT: + case LONG: + case MODULE: + case NEW: + case OPEN: + case OPENS: + case PROVIDES: + case REQUIRES: + case SHORT: + case SUPER: + case THIS: + case TO: + case USES: + case VOID: + case WITH: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INC: + case DEC: + case ADD: + case SUB: + case Identifier: + EnterOuterAlt(_localctx, 1); + { + State = 2731; expression(); + } + break; + case LBRACE: + EnterOuterAlt(_localctx, 2); + { + State = 2732; block(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AssignmentExpressionContext : ParserRuleContext { + public ConditionalExpressionContext conditionalExpression() { + return GetRuleContext(0); + } + public AssignmentContext assignment() { + return GetRuleContext(0); + } + public AssignmentExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_assignmentExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAssignmentExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAssignmentExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAssignmentExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AssignmentExpressionContext assignmentExpression() { + AssignmentExpressionContext _localctx = new AssignmentExpressionContext(Context, State); + EnterRule(_localctx, 438, RULE_assignmentExpression); + try { + State = 2737; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,313,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2735; conditionalExpression(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2736; assignment(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AssignmentContext : ParserRuleContext { + public LeftHandSideContext leftHandSide() { + return GetRuleContext(0); + } + public AssignmentOperatorContext assignmentOperator() { + return GetRuleContext(0); + } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public AssignmentContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_assignment; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAssignment(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAssignment(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAssignment(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AssignmentContext assignment() { + AssignmentContext _localctx = new AssignmentContext(Context, State); + EnterRule(_localctx, 440, RULE_assignment); + try { + EnterOuterAlt(_localctx, 1); + { + State = 2739; leftHandSide(); + State = 2740; assignmentOperator(); + State = 2741; expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class LeftHandSideContext : ParserRuleContext { + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public FieldAccessContext fieldAccess() { + return GetRuleContext(0); + } + public ArrayAccessContext arrayAccess() { + return GetRuleContext(0); + } + public LeftHandSideContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_leftHandSide; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterLeftHandSide(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitLeftHandSide(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitLeftHandSide(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public LeftHandSideContext leftHandSide() { + LeftHandSideContext _localctx = new LeftHandSideContext(Context, State); + EnterRule(_localctx, 442, RULE_leftHandSide); + try { + State = 2746; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,314,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2743; expressionName(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2744; fieldAccess(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2745; arrayAccess(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class AssignmentOperatorContext : ParserRuleContext { + public ITerminalNode ASSIGN() { return GetToken(Java9Parser.ASSIGN, 0); } + public ITerminalNode MUL_ASSIGN() { return GetToken(Java9Parser.MUL_ASSIGN, 0); } + public ITerminalNode DIV_ASSIGN() { return GetToken(Java9Parser.DIV_ASSIGN, 0); } + public ITerminalNode MOD_ASSIGN() { return GetToken(Java9Parser.MOD_ASSIGN, 0); } + public ITerminalNode ADD_ASSIGN() { return GetToken(Java9Parser.ADD_ASSIGN, 0); } + public ITerminalNode SUB_ASSIGN() { return GetToken(Java9Parser.SUB_ASSIGN, 0); } + public ITerminalNode LSHIFT_ASSIGN() { return GetToken(Java9Parser.LSHIFT_ASSIGN, 0); } + public ITerminalNode RSHIFT_ASSIGN() { return GetToken(Java9Parser.RSHIFT_ASSIGN, 0); } + public ITerminalNode URSHIFT_ASSIGN() { return GetToken(Java9Parser.URSHIFT_ASSIGN, 0); } + public ITerminalNode AND_ASSIGN() { return GetToken(Java9Parser.AND_ASSIGN, 0); } + public ITerminalNode XOR_ASSIGN() { return GetToken(Java9Parser.XOR_ASSIGN, 0); } + public ITerminalNode OR_ASSIGN() { return GetToken(Java9Parser.OR_ASSIGN, 0); } + public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_assignmentOperator; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAssignmentOperator(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAssignmentOperator(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAssignmentOperator(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AssignmentOperatorContext assignmentOperator() { + AssignmentOperatorContext _localctx = new AssignmentOperatorContext(Context, State); + EnterRule(_localctx, 444, RULE_assignmentOperator); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 2748; + _la = TokenStream.LA(1); + if ( !(((((_la - 80)) & ~0x3f) == 0 && ((1L << (_la - 80)) & ((1L << (ASSIGN - 80)) | (1L << (ADD_ASSIGN - 80)) | (1L << (SUB_ASSIGN - 80)) | (1L << (MUL_ASSIGN - 80)) | (1L << (DIV_ASSIGN - 80)) | (1L << (AND_ASSIGN - 80)) | (1L << (OR_ASSIGN - 80)) | (1L << (XOR_ASSIGN - 80)) | (1L << (MOD_ASSIGN - 80)) | (1L << (LSHIFT_ASSIGN - 80)) | (1L << (RSHIFT_ASSIGN - 80)) | (1L << (URSHIFT_ASSIGN - 80)))) != 0)) ) { + ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ConditionalExpressionContext : ParserRuleContext { + public ConditionalOrExpressionContext conditionalOrExpression() { + return GetRuleContext(0); + } + public ITerminalNode QUESTION() { return GetToken(Java9Parser.QUESTION, 0); } + public ExpressionContext expression() { + return GetRuleContext(0); + } + public ITerminalNode COLON() { return GetToken(Java9Parser.COLON, 0); } + public ConditionalExpressionContext conditionalExpression() { + return GetRuleContext(0); + } + public LambdaExpressionContext lambdaExpression() { + return GetRuleContext(0); + } + public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_conditionalExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterConditionalExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitConditionalExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitConditionalExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ConditionalExpressionContext conditionalExpression() { + ConditionalExpressionContext _localctx = new ConditionalExpressionContext(Context, State); + EnterRule(_localctx, 446, RULE_conditionalExpression); + try { + State = 2759; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,316,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2750; conditionalOrExpression(0); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2751; conditionalOrExpression(0); + State = 2752; Match(QUESTION); + State = 2753; expression(); + State = 2754; Match(COLON); + State = 2757; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,315,Context) ) { + case 1: + { + State = 2755; conditionalExpression(); + } + break; + case 2: + { + State = 2756; lambdaExpression(); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ConditionalOrExpressionContext : ParserRuleContext { + public ConditionalAndExpressionContext conditionalAndExpression() { + return GetRuleContext(0); + } + public ConditionalOrExpressionContext conditionalOrExpression() { + return GetRuleContext(0); + } + public ITerminalNode OR() { return GetToken(Java9Parser.OR, 0); } + public ConditionalOrExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_conditionalOrExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterConditionalOrExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitConditionalOrExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitConditionalOrExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ConditionalOrExpressionContext conditionalOrExpression() { + return conditionalOrExpression(0); + } + + private ConditionalOrExpressionContext conditionalOrExpression(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + ConditionalOrExpressionContext _localctx = new ConditionalOrExpressionContext(Context, _parentState); + ConditionalOrExpressionContext _prevctx = _localctx; + int _startState = 448; + EnterRecursionRule(_localctx, 448, RULE_conditionalOrExpression, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 2762; conditionalAndExpression(0); + } + Context.Stop = TokenStream.LT(-1); + State = 2769; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,317,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new ConditionalOrExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_conditionalOrExpression); + State = 2764; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 2765; Match(OR); + State = 2766; conditionalAndExpression(0); + } + } + } + State = 2771; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,317,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class ConditionalAndExpressionContext : ParserRuleContext { + public InclusiveOrExpressionContext inclusiveOrExpression() { + return GetRuleContext(0); + } + public ConditionalAndExpressionContext conditionalAndExpression() { + return GetRuleContext(0); + } + public ITerminalNode AND() { return GetToken(Java9Parser.AND, 0); } + public ConditionalAndExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_conditionalAndExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterConditionalAndExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitConditionalAndExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitConditionalAndExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ConditionalAndExpressionContext conditionalAndExpression() { + return conditionalAndExpression(0); + } + + private ConditionalAndExpressionContext conditionalAndExpression(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + ConditionalAndExpressionContext _localctx = new ConditionalAndExpressionContext(Context, _parentState); + ConditionalAndExpressionContext _prevctx = _localctx; + int _startState = 450; + EnterRecursionRule(_localctx, 450, RULE_conditionalAndExpression, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 2773; inclusiveOrExpression(0); + } + Context.Stop = TokenStream.LT(-1); + State = 2780; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,318,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new ConditionalAndExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_conditionalAndExpression); + State = 2775; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 2776; Match(AND); + State = 2777; inclusiveOrExpression(0); + } + } + } + State = 2782; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,318,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class InclusiveOrExpressionContext : ParserRuleContext { + public ExclusiveOrExpressionContext exclusiveOrExpression() { + return GetRuleContext(0); + } + public InclusiveOrExpressionContext inclusiveOrExpression() { + return GetRuleContext(0); + } + public ITerminalNode BITOR() { return GetToken(Java9Parser.BITOR, 0); } + public InclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_inclusiveOrExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterInclusiveOrExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitInclusiveOrExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitInclusiveOrExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public InclusiveOrExpressionContext inclusiveOrExpression() { + return inclusiveOrExpression(0); + } + + private InclusiveOrExpressionContext inclusiveOrExpression(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + InclusiveOrExpressionContext _localctx = new InclusiveOrExpressionContext(Context, _parentState); + InclusiveOrExpressionContext _prevctx = _localctx; + int _startState = 452; + EnterRecursionRule(_localctx, 452, RULE_inclusiveOrExpression, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 2784; exclusiveOrExpression(0); + } + Context.Stop = TokenStream.LT(-1); + State = 2791; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,319,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new InclusiveOrExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_inclusiveOrExpression); + State = 2786; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 2787; Match(BITOR); + State = 2788; exclusiveOrExpression(0); + } + } + } + State = 2793; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,319,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class ExclusiveOrExpressionContext : ParserRuleContext { + public AndExpressionContext andExpression() { + return GetRuleContext(0); + } + public ExclusiveOrExpressionContext exclusiveOrExpression() { + return GetRuleContext(0); + } + public ITerminalNode CARET() { return GetToken(Java9Parser.CARET, 0); } + public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_exclusiveOrExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterExclusiveOrExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitExclusiveOrExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitExclusiveOrExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ExclusiveOrExpressionContext exclusiveOrExpression() { + return exclusiveOrExpression(0); + } + + private ExclusiveOrExpressionContext exclusiveOrExpression(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(Context, _parentState); + ExclusiveOrExpressionContext _prevctx = _localctx; + int _startState = 454; + EnterRecursionRule(_localctx, 454, RULE_exclusiveOrExpression, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 2795; andExpression(0); + } + Context.Stop = TokenStream.LT(-1); + State = 2802; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,320,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new ExclusiveOrExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_exclusiveOrExpression); + State = 2797; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 2798; Match(CARET); + State = 2799; andExpression(0); + } + } + } + State = 2804; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,320,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class AndExpressionContext : ParserRuleContext { + public EqualityExpressionContext equalityExpression() { + return GetRuleContext(0); + } + public AndExpressionContext andExpression() { + return GetRuleContext(0); + } + public ITerminalNode BITAND() { return GetToken(Java9Parser.BITAND, 0); } + public AndExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_andExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAndExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAndExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAndExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AndExpressionContext andExpression() { + return andExpression(0); + } + + private AndExpressionContext andExpression(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + AndExpressionContext _localctx = new AndExpressionContext(Context, _parentState); + AndExpressionContext _prevctx = _localctx; + int _startState = 456; + EnterRecursionRule(_localctx, 456, RULE_andExpression, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 2806; equalityExpression(0); + } + Context.Stop = TokenStream.LT(-1); + State = 2813; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,321,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new AndExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_andExpression); + State = 2808; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 2809; Match(BITAND); + State = 2810; equalityExpression(0); + } + } + } + State = 2815; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,321,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class EqualityExpressionContext : ParserRuleContext { + public RelationalExpressionContext relationalExpression() { + return GetRuleContext(0); + } + public EqualityExpressionContext equalityExpression() { + return GetRuleContext(0); + } + public ITerminalNode EQUAL() { return GetToken(Java9Parser.EQUAL, 0); } + public ITerminalNode NOTEQUAL() { return GetToken(Java9Parser.NOTEQUAL, 0); } + public EqualityExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_equalityExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterEqualityExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitEqualityExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitEqualityExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public EqualityExpressionContext equalityExpression() { + return equalityExpression(0); + } + + private EqualityExpressionContext equalityExpression(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + EqualityExpressionContext _localctx = new EqualityExpressionContext(Context, _parentState); + EqualityExpressionContext _prevctx = _localctx; + int _startState = 458; + EnterRecursionRule(_localctx, 458, RULE_equalityExpression, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 2817; relationalExpression(0); + } + Context.Stop = TokenStream.LT(-1); + State = 2827; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,323,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + State = 2825; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,322,Context) ) { + case 1: + { + _localctx = new EqualityExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_equalityExpression); + State = 2819; + if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); + State = 2820; Match(EQUAL); + State = 2821; relationalExpression(0); + } + break; + case 2: + { + _localctx = new EqualityExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_equalityExpression); + State = 2822; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 2823; Match(NOTEQUAL); + State = 2824; relationalExpression(0); + } + break; + } + } + } + State = 2829; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,323,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class RelationalExpressionContext : ParserRuleContext { + public ShiftExpressionContext shiftExpression() { + return GetRuleContext(0); + } + public RelationalExpressionContext relationalExpression() { + return GetRuleContext(0); + } + public ITerminalNode LT() { return GetToken(Java9Parser.LT, 0); } + public ITerminalNode GT() { return GetToken(Java9Parser.GT, 0); } + public ITerminalNode LE() { return GetToken(Java9Parser.LE, 0); } + public ITerminalNode GE() { return GetToken(Java9Parser.GE, 0); } + public ITerminalNode INSTANCEOF() { return GetToken(Java9Parser.INSTANCEOF, 0); } + public ReferenceTypeContext referenceType() { + return GetRuleContext(0); + } + public RelationalExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_relationalExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterRelationalExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitRelationalExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitRelationalExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public RelationalExpressionContext relationalExpression() { + return relationalExpression(0); + } + + private RelationalExpressionContext relationalExpression(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + RelationalExpressionContext _localctx = new RelationalExpressionContext(Context, _parentState); + RelationalExpressionContext _prevctx = _localctx; + int _startState = 460; + EnterRecursionRule(_localctx, 460, RULE_relationalExpression, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 2831; shiftExpression(0); + } + Context.Stop = TokenStream.LT(-1); + State = 2850; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,325,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + State = 2848; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,324,Context) ) { + case 1: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + State = 2833; + if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)"); + State = 2834; Match(LT); + State = 2835; shiftExpression(0); + } + break; + case 2: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + State = 2836; + if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)"); + State = 2837; Match(GT); + State = 2838; shiftExpression(0); + } + break; + case 3: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + State = 2839; + if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); + State = 2840; Match(LE); + State = 2841; shiftExpression(0); + } + break; + case 4: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + State = 2842; + if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); + State = 2843; Match(GE); + State = 2844; shiftExpression(0); + } + break; + case 5: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + State = 2845; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 2846; Match(INSTANCEOF); + State = 2847; referenceType(); + } + break; + } + } + } + State = 2852; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,325,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class ShiftExpressionContext : ParserRuleContext { + public AdditiveExpressionContext additiveExpression() { + return GetRuleContext(0); + } + public ShiftExpressionContext shiftExpression() { + return GetRuleContext(0); + } + public ITerminalNode[] LT() { return GetTokens(Java9Parser.LT); } + public ITerminalNode LT(int i) { + return GetToken(Java9Parser.LT, i); + } + public ITerminalNode[] GT() { return GetTokens(Java9Parser.GT); } + public ITerminalNode GT(int i) { + return GetToken(Java9Parser.GT, i); + } + public ShiftExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_shiftExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterShiftExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitShiftExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitShiftExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ShiftExpressionContext shiftExpression() { + return shiftExpression(0); + } + + private ShiftExpressionContext shiftExpression(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + ShiftExpressionContext _localctx = new ShiftExpressionContext(Context, _parentState); + ShiftExpressionContext _prevctx = _localctx; + int _startState = 462; + EnterRecursionRule(_localctx, 462, RULE_shiftExpression, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 2854; additiveExpression(0); + } + Context.Stop = TokenStream.LT(-1); + State = 2873; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,327,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + State = 2871; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,326,Context) ) { + case 1: + { + _localctx = new ShiftExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); + State = 2856; + if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); + State = 2857; Match(LT); + State = 2858; Match(LT); + State = 2859; additiveExpression(0); + } + break; + case 2: + { + _localctx = new ShiftExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); + State = 2860; + if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); + State = 2861; Match(GT); + State = 2862; + if (!( this.CurrentToken.Column + 1 == this.TokenStream.Get(this.CurrentToken.TokenIndex + 1).Column )) throw new FailedPredicateException(this, " this.CurrentToken.Column + 1 == this.TokenStream.Get(this.CurrentToken.TokenIndex + 1).Column "); + State = 2863; Match(GT); + State = 2864; + if (!( this.CurrentToken.Column + 1 == this.TokenStream.Get(this.CurrentToken.TokenIndex + 1).Column )) throw new FailedPredicateException(this, " this.CurrentToken.Column + 1 == this.TokenStream.Get(this.CurrentToken.TokenIndex + 1).Column "); + State = 2865; additiveExpression(0); + } + break; + case 3: + { + _localctx = new ShiftExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); + State = 2866; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 2867; Match(GT); + State = 2868; Match(GT); + State = 2869; Match(GT); + State = 2870; additiveExpression(0); + } + break; + } + } + } + State = 2875; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,327,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class AdditiveExpressionContext : ParserRuleContext { + public MultiplicativeExpressionContext multiplicativeExpression() { + return GetRuleContext(0); + } + public AdditiveExpressionContext additiveExpression() { + return GetRuleContext(0); + } + public ITerminalNode ADD() { return GetToken(Java9Parser.ADD, 0); } + public ITerminalNode SUB() { return GetToken(Java9Parser.SUB, 0); } + public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_additiveExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterAdditiveExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitAdditiveExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitAdditiveExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AdditiveExpressionContext additiveExpression() { + return additiveExpression(0); + } + + private AdditiveExpressionContext additiveExpression(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + AdditiveExpressionContext _localctx = new AdditiveExpressionContext(Context, _parentState); + AdditiveExpressionContext _prevctx = _localctx; + int _startState = 464; + EnterRecursionRule(_localctx, 464, RULE_additiveExpression, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 2877; multiplicativeExpression(0); + } + Context.Stop = TokenStream.LT(-1); + State = 2887; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,329,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + State = 2885; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,328,Context) ) { + case 1: + { + _localctx = new AdditiveExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_additiveExpression); + State = 2879; + if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); + State = 2880; Match(ADD); + State = 2881; multiplicativeExpression(0); + } + break; + case 2: + { + _localctx = new AdditiveExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_additiveExpression); + State = 2882; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 2883; Match(SUB); + State = 2884; multiplicativeExpression(0); + } + break; + } + } + } + State = 2889; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,329,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class MultiplicativeExpressionContext : ParserRuleContext { + public UnaryExpressionContext unaryExpression() { + return GetRuleContext(0); + } + public MultiplicativeExpressionContext multiplicativeExpression() { + return GetRuleContext(0); + } + public ITerminalNode MUL() { return GetToken(Java9Parser.MUL, 0); } + public ITerminalNode DIV() { return GetToken(Java9Parser.DIV, 0); } + public ITerminalNode MOD() { return GetToken(Java9Parser.MOD, 0); } + public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_multiplicativeExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterMultiplicativeExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitMultiplicativeExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitMultiplicativeExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MultiplicativeExpressionContext multiplicativeExpression() { + return multiplicativeExpression(0); + } + + private MultiplicativeExpressionContext multiplicativeExpression(int _p) { + ParserRuleContext _parentctx = Context; + int _parentState = State; + MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(Context, _parentState); + MultiplicativeExpressionContext _prevctx = _localctx; + int _startState = 466; + EnterRecursionRule(_localctx, 466, RULE_multiplicativeExpression, _p); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + { + State = 2891; unaryExpression(); + } + Context.Stop = TokenStream.LT(-1); + State = 2904; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,331,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( ParseListeners!=null ) + TriggerExitRuleEvent(); + _prevctx = _localctx; + { + State = 2902; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,330,Context) ) { + case 1: + { + _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); + State = 2893; + if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); + State = 2894; Match(MUL); + State = 2895; unaryExpression(); + } + break; + case 2: + { + _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); + State = 2896; + if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); + State = 2897; Match(DIV); + State = 2898; unaryExpression(); + } + break; + case 3: + { + _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); + PushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); + State = 2899; + if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); + State = 2900; Match(MOD); + State = 2901; unaryExpression(); + } + break; + } + } + } + State = 2906; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,331,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + UnrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public partial class UnaryExpressionContext : ParserRuleContext { + public PreIncrementExpressionContext preIncrementExpression() { + return GetRuleContext(0); + } + public PreDecrementExpressionContext preDecrementExpression() { + return GetRuleContext(0); + } + public ITerminalNode ADD() { return GetToken(Java9Parser.ADD, 0); } + public UnaryExpressionContext unaryExpression() { + return GetRuleContext(0); + } + public ITerminalNode SUB() { return GetToken(Java9Parser.SUB, 0); } + public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() { + return GetRuleContext(0); + } + public UnaryExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unaryExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnaryExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnaryExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnaryExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnaryExpressionContext unaryExpression() { + UnaryExpressionContext _localctx = new UnaryExpressionContext(Context, State); + EnterRule(_localctx, 468, RULE_unaryExpression); + try { + State = 2914; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case INC: + EnterOuterAlt(_localctx, 1); + { + State = 2907; preIncrementExpression(); + } + break; + case DEC: + EnterOuterAlt(_localctx, 2); + { + State = 2908; preDecrementExpression(); + } + break; + case ADD: + EnterOuterAlt(_localctx, 3); + { + State = 2909; Match(ADD); + State = 2910; unaryExpression(); + } + break; + case SUB: + EnterOuterAlt(_localctx, 4); + { + State = 2911; Match(SUB); + State = 2912; unaryExpression(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case EXPORTS: + case FLOAT: + case INT: + case LONG: + case MODULE: + case NEW: + case OPEN: + case OPENS: + case PROVIDES: + case REQUIRES: + case SHORT: + case SUPER: + case THIS: + case TO: + case USES: + case VOID: + case WITH: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case AT: + case BANG: + case TILDE: + case Identifier: + EnterOuterAlt(_localctx, 5); + { + State = 2913; unaryExpressionNotPlusMinus(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PreIncrementExpressionContext : ParserRuleContext { + public ITerminalNode INC() { return GetToken(Java9Parser.INC, 0); } + public UnaryExpressionContext unaryExpression() { + return GetRuleContext(0); + } + public PreIncrementExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_preIncrementExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPreIncrementExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPreIncrementExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPreIncrementExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PreIncrementExpressionContext preIncrementExpression() { + PreIncrementExpressionContext _localctx = new PreIncrementExpressionContext(Context, State); + EnterRule(_localctx, 470, RULE_preIncrementExpression); + try { + EnterOuterAlt(_localctx, 1); + { + State = 2916; Match(INC); + State = 2917; unaryExpression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PreDecrementExpressionContext : ParserRuleContext { + public ITerminalNode DEC() { return GetToken(Java9Parser.DEC, 0); } + public UnaryExpressionContext unaryExpression() { + return GetRuleContext(0); + } + public PreDecrementExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_preDecrementExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPreDecrementExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPreDecrementExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPreDecrementExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PreDecrementExpressionContext preDecrementExpression() { + PreDecrementExpressionContext _localctx = new PreDecrementExpressionContext(Context, State); + EnterRule(_localctx, 472, RULE_preDecrementExpression); + try { + EnterOuterAlt(_localctx, 1); + { + State = 2919; Match(DEC); + State = 2920; unaryExpression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class UnaryExpressionNotPlusMinusContext : ParserRuleContext { + public PostfixExpressionContext postfixExpression() { + return GetRuleContext(0); + } + public ITerminalNode TILDE() { return GetToken(Java9Parser.TILDE, 0); } + public UnaryExpressionContext unaryExpression() { + return GetRuleContext(0); + } + public ITerminalNode BANG() { return GetToken(Java9Parser.BANG, 0); } + public CastExpressionContext castExpression() { + return GetRuleContext(0); + } + public UnaryExpressionNotPlusMinusContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_unaryExpressionNotPlusMinus; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterUnaryExpressionNotPlusMinus(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitUnaryExpressionNotPlusMinus(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitUnaryExpressionNotPlusMinus(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() { + UnaryExpressionNotPlusMinusContext _localctx = new UnaryExpressionNotPlusMinusContext(Context, State); + EnterRule(_localctx, 474, RULE_unaryExpressionNotPlusMinus); + try { + State = 2928; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,333,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2922; postfixExpression(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2923; Match(TILDE); + State = 2924; unaryExpression(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2925; Match(BANG); + State = 2926; unaryExpression(); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 2927; castExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PostfixExpressionContext : ParserRuleContext { + public PrimaryContext primary() { + return GetRuleContext(0); + } + public ExpressionNameContext expressionName() { + return GetRuleContext(0); + } + public PostIncrementExpression_lf_postfixExpressionContext[] postIncrementExpression_lf_postfixExpression() { + return GetRuleContexts(); + } + public PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression(int i) { + return GetRuleContext(i); + } + public PostDecrementExpression_lf_postfixExpressionContext[] postDecrementExpression_lf_postfixExpression() { + return GetRuleContexts(); + } + public PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression(int i) { + return GetRuleContext(i); + } + public PostfixExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_postfixExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPostfixExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPostfixExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPostfixExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PostfixExpressionContext postfixExpression() { + PostfixExpressionContext _localctx = new PostfixExpressionContext(Context, State); + EnterRule(_localctx, 476, RULE_postfixExpression); + try { + int _alt; + EnterOuterAlt(_localctx, 1); + { + State = 2932; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,334,Context) ) { + case 1: + { + State = 2930; primary(); + } + break; + case 2: + { + State = 2931; expressionName(); + } + break; + } + State = 2938; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,336,Context); + while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + State = 2936; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case INC: + { + State = 2934; postIncrementExpression_lf_postfixExpression(); + } + break; + case DEC: + { + State = 2935; postDecrementExpression_lf_postfixExpression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + State = 2940; + ErrorHandler.Sync(this); + _alt = Interpreter.AdaptivePredict(TokenStream,336,Context); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PostIncrementExpressionContext : ParserRuleContext { + public PostfixExpressionContext postfixExpression() { + return GetRuleContext(0); + } + public ITerminalNode INC() { return GetToken(Java9Parser.INC, 0); } + public PostIncrementExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_postIncrementExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPostIncrementExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPostIncrementExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPostIncrementExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PostIncrementExpressionContext postIncrementExpression() { + PostIncrementExpressionContext _localctx = new PostIncrementExpressionContext(Context, State); + EnterRule(_localctx, 478, RULE_postIncrementExpression); + try { + EnterOuterAlt(_localctx, 1); + { + State = 2941; postfixExpression(); + State = 2942; Match(INC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PostIncrementExpression_lf_postfixExpressionContext : ParserRuleContext { + public ITerminalNode INC() { return GetToken(Java9Parser.INC, 0); } + public PostIncrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_postIncrementExpression_lf_postfixExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPostIncrementExpression_lf_postfixExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPostIncrementExpression_lf_postfixExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPostIncrementExpression_lf_postfixExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression() { + PostIncrementExpression_lf_postfixExpressionContext _localctx = new PostIncrementExpression_lf_postfixExpressionContext(Context, State); + EnterRule(_localctx, 480, RULE_postIncrementExpression_lf_postfixExpression); + try { + EnterOuterAlt(_localctx, 1); + { + State = 2944; Match(INC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PostDecrementExpressionContext : ParserRuleContext { + public PostfixExpressionContext postfixExpression() { + return GetRuleContext(0); + } + public ITerminalNode DEC() { return GetToken(Java9Parser.DEC, 0); } + public PostDecrementExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_postDecrementExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPostDecrementExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPostDecrementExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPostDecrementExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PostDecrementExpressionContext postDecrementExpression() { + PostDecrementExpressionContext _localctx = new PostDecrementExpressionContext(Context, State); + EnterRule(_localctx, 482, RULE_postDecrementExpression); + try { + EnterOuterAlt(_localctx, 1); + { + State = 2946; postfixExpression(); + State = 2947; Match(DEC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class PostDecrementExpression_lf_postfixExpressionContext : ParserRuleContext { + public ITerminalNode DEC() { return GetToken(Java9Parser.DEC, 0); } + public PostDecrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_postDecrementExpression_lf_postfixExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterPostDecrementExpression_lf_postfixExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitPostDecrementExpression_lf_postfixExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitPostDecrementExpression_lf_postfixExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression() { + PostDecrementExpression_lf_postfixExpressionContext _localctx = new PostDecrementExpression_lf_postfixExpressionContext(Context, State); + EnterRule(_localctx, 484, RULE_postDecrementExpression_lf_postfixExpression); + try { + EnterOuterAlt(_localctx, 1); + { + State = 2949; Match(DEC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class CastExpressionContext : ParserRuleContext { + public ITerminalNode LPAREN() { return GetToken(Java9Parser.LPAREN, 0); } + public PrimitiveTypeContext primitiveType() { + return GetRuleContext(0); + } + public ITerminalNode RPAREN() { return GetToken(Java9Parser.RPAREN, 0); } + public UnaryExpressionContext unaryExpression() { + return GetRuleContext(0); + } + public ReferenceTypeContext referenceType() { + return GetRuleContext(0); + } + public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() { + return GetRuleContext(0); + } + public AdditionalBoundContext[] additionalBound() { + return GetRuleContexts(); + } + public AdditionalBoundContext additionalBound(int i) { + return GetRuleContext(i); + } + public LambdaExpressionContext lambdaExpression() { + return GetRuleContext(0); + } + public CastExpressionContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_castExpression; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterCastExpression(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitCastExpression(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitCastExpression(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public CastExpressionContext castExpression() { + CastExpressionContext _localctx = new CastExpressionContext(Context, State); + EnterRule(_localctx, 486, RULE_castExpression); + int _la; + try { + State = 2978; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,339,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 2951; Match(LPAREN); + State = 2952; primitiveType(); + State = 2953; Match(RPAREN); + State = 2954; unaryExpression(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 2956; Match(LPAREN); + State = 2957; referenceType(); + State = 2961; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==BITAND) { + { + { + State = 2958; additionalBound(); + } + } + State = 2963; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2964; Match(RPAREN); + State = 2965; unaryExpressionNotPlusMinus(); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 2967; Match(LPAREN); + State = 2968; referenceType(); + State = 2972; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==BITAND) { + { + { + State = 2969; additionalBound(); + } + } + State = 2974; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + State = 2975; Match(RPAREN); + State = 2976; lambdaExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class IdentifierContext : ParserRuleContext { + public ITerminalNode Identifier() { return GetToken(Java9Parser.Identifier, 0); } + public ITerminalNode TO() { return GetToken(Java9Parser.TO, 0); } + public ITerminalNode MODULE() { return GetToken(Java9Parser.MODULE, 0); } + public ITerminalNode OPEN() { return GetToken(Java9Parser.OPEN, 0); } + public ITerminalNode WITH() { return GetToken(Java9Parser.WITH, 0); } + public ITerminalNode PROVIDES() { return GetToken(Java9Parser.PROVIDES, 0); } + public ITerminalNode USES() { return GetToken(Java9Parser.USES, 0); } + public ITerminalNode OPENS() { return GetToken(Java9Parser.OPENS, 0); } + public ITerminalNode REQUIRES() { return GetToken(Java9Parser.REQUIRES, 0); } + public ITerminalNode EXPORTS() { return GetToken(Java9Parser.EXPORTS, 0); } + public IdentifierContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_identifier; } } + public override void EnterRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.EnterIdentifier(this); + } + public override void ExitRule(IParseTreeListener listener) { + IJava9ParserListener typedListener = listener as IJava9ParserListener; + if (typedListener != null) typedListener.ExitIdentifier(this); + } + public override TResult Accept(IParseTreeVisitor visitor) { + IJava9ParserVisitor typedVisitor = visitor as IJava9ParserVisitor; + if (typedVisitor != null) return typedVisitor.VisitIdentifier(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public IdentifierContext identifier() { + IdentifierContext _localctx = new IdentifierContext(Context, State); + EnterRule(_localctx, 488, RULE_identifier); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 2980; + _la = TokenStream.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXPORTS) | (1L << MODULE) | (1L << OPEN) | (1L << OPENS) | (1L << PROVIDES) | (1L << REQUIRES) | (1L << TO) | (1L << USES) | (1L << WITH))) != 0) || _la==Identifier) ) { + ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 25: return moduleName_sempred((ModuleNameContext)_localctx, predIndex); + case 26: return packageName_sempred((PackageNameContext)_localctx, predIndex); + case 28: return packageOrTypeName_sempred((PackageOrTypeNameContext)_localctx, predIndex); + case 31: return ambiguousName_sempred((AmbiguousNameContext)_localctx, predIndex); + case 224: return conditionalOrExpression_sempred((ConditionalOrExpressionContext)_localctx, predIndex); + case 225: return conditionalAndExpression_sempred((ConditionalAndExpressionContext)_localctx, predIndex); + case 226: return inclusiveOrExpression_sempred((InclusiveOrExpressionContext)_localctx, predIndex); + case 227: return exclusiveOrExpression_sempred((ExclusiveOrExpressionContext)_localctx, predIndex); + case 228: return andExpression_sempred((AndExpressionContext)_localctx, predIndex); + case 229: return equalityExpression_sempred((EqualityExpressionContext)_localctx, predIndex); + case 230: return relationalExpression_sempred((RelationalExpressionContext)_localctx, predIndex); + case 231: return shiftExpression_sempred((ShiftExpressionContext)_localctx, predIndex); + case 232: return additiveExpression_sempred((AdditiveExpressionContext)_localctx, predIndex); + case 233: return multiplicativeExpression_sempred((MultiplicativeExpressionContext)_localctx, predIndex); + } + return true; + } + private bool moduleName_sempred(ModuleNameContext _localctx, int predIndex) { + switch (predIndex) { + case 0: return Precpred(Context, 1); + } + return true; + } + private bool packageName_sempred(PackageNameContext _localctx, int predIndex) { + switch (predIndex) { + case 1: return Precpred(Context, 1); + } + return true; + } + private bool packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, int predIndex) { + switch (predIndex) { + case 2: return Precpred(Context, 1); + } + return true; + } + private bool ambiguousName_sempred(AmbiguousNameContext _localctx, int predIndex) { + switch (predIndex) { + case 3: return Precpred(Context, 1); + } + return true; + } + private bool conditionalOrExpression_sempred(ConditionalOrExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 4: return Precpred(Context, 1); + } + return true; + } + private bool conditionalAndExpression_sempred(ConditionalAndExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 5: return Precpred(Context, 1); + } + return true; + } + private bool inclusiveOrExpression_sempred(InclusiveOrExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 6: return Precpred(Context, 1); + } + return true; + } + private bool exclusiveOrExpression_sempred(ExclusiveOrExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 7: return Precpred(Context, 1); + } + return true; + } + private bool andExpression_sempred(AndExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 8: return Precpred(Context, 1); + } + return true; + } + private bool equalityExpression_sempred(EqualityExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 9: return Precpred(Context, 2); + case 10: return Precpred(Context, 1); + } + return true; + } + private bool relationalExpression_sempred(RelationalExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 11: return Precpred(Context, 5); + case 12: return Precpred(Context, 4); + case 13: return Precpred(Context, 3); + case 14: return Precpred(Context, 2); + case 15: return Precpred(Context, 1); + } + return true; + } + private bool shiftExpression_sempred(ShiftExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 16: return Precpred(Context, 3); + case 17: return Precpred(Context, 2); + case 18: return this.CurrentToken.Column + 1 == this.TokenStream.Get(this.CurrentToken.TokenIndex + 1).Column ; + case 19: return this.CurrentToken.Column + 1 == this.TokenStream.Get(this.CurrentToken.TokenIndex + 1).Column ; + case 20: return Precpred(Context, 1); + } + return true; + } + private bool additiveExpression_sempred(AdditiveExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 21: return Precpred(Context, 2); + case 22: return Precpred(Context, 1); + } + return true; + } + private bool multiplicativeExpression_sempred(MultiplicativeExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 23: return Precpred(Context, 3); + case 24: return Precpred(Context, 2); + case 25: return Precpred(Context, 1); + } + return true; + } + + private static char[] _serializedATN = { + '\x3', '\x608B', '\xA72A', '\x8133', '\xB9ED', '\x417C', '\x3BE7', '\x7786', + '\x5964', '\x3', 'x', '\xBA9', '\x4', '\x2', '\t', '\x2', '\x4', '\x3', + '\t', '\x3', '\x4', '\x4', '\t', '\x4', '\x4', '\x5', '\t', '\x5', '\x4', + '\x6', '\t', '\x6', '\x4', '\a', '\t', '\a', '\x4', '\b', '\t', '\b', + '\x4', '\t', '\t', '\t', '\x4', '\n', '\t', '\n', '\x4', '\v', '\t', '\v', + '\x4', '\f', '\t', '\f', '\x4', '\r', '\t', '\r', '\x4', '\xE', '\t', + '\xE', '\x4', '\xF', '\t', '\xF', '\x4', '\x10', '\t', '\x10', '\x4', + '\x11', '\t', '\x11', '\x4', '\x12', '\t', '\x12', '\x4', '\x13', '\t', + '\x13', '\x4', '\x14', '\t', '\x14', '\x4', '\x15', '\t', '\x15', '\x4', + '\x16', '\t', '\x16', '\x4', '\x17', '\t', '\x17', '\x4', '\x18', '\t', + '\x18', '\x4', '\x19', '\t', '\x19', '\x4', '\x1A', '\t', '\x1A', '\x4', + '\x1B', '\t', '\x1B', '\x4', '\x1C', '\t', '\x1C', '\x4', '\x1D', '\t', + '\x1D', '\x4', '\x1E', '\t', '\x1E', '\x4', '\x1F', '\t', '\x1F', '\x4', + ' ', '\t', ' ', '\x4', '!', '\t', '!', '\x4', '\"', '\t', '\"', '\x4', + '#', '\t', '#', '\x4', '$', '\t', '$', '\x4', '%', '\t', '%', '\x4', '&', + '\t', '&', '\x4', '\'', '\t', '\'', '\x4', '(', '\t', '(', '\x4', ')', + '\t', ')', '\x4', '*', '\t', '*', '\x4', '+', '\t', '+', '\x4', ',', '\t', + ',', '\x4', '-', '\t', '-', '\x4', '.', '\t', '.', '\x4', '/', '\t', '/', + '\x4', '\x30', '\t', '\x30', '\x4', '\x31', '\t', '\x31', '\x4', '\x32', + '\t', '\x32', '\x4', '\x33', '\t', '\x33', '\x4', '\x34', '\t', '\x34', + '\x4', '\x35', '\t', '\x35', '\x4', '\x36', '\t', '\x36', '\x4', '\x37', + '\t', '\x37', '\x4', '\x38', '\t', '\x38', '\x4', '\x39', '\t', '\x39', + '\x4', ':', '\t', ':', '\x4', ';', '\t', ';', '\x4', '<', '\t', '<', '\x4', + '=', '\t', '=', '\x4', '>', '\t', '>', '\x4', '?', '\t', '?', '\x4', '@', + '\t', '@', '\x4', '\x41', '\t', '\x41', '\x4', '\x42', '\t', '\x42', '\x4', + '\x43', '\t', '\x43', '\x4', '\x44', '\t', '\x44', '\x4', '\x45', '\t', + '\x45', '\x4', '\x46', '\t', '\x46', '\x4', 'G', '\t', 'G', '\x4', 'H', + '\t', 'H', '\x4', 'I', '\t', 'I', '\x4', 'J', '\t', 'J', '\x4', 'K', '\t', + 'K', '\x4', 'L', '\t', 'L', '\x4', 'M', '\t', 'M', '\x4', 'N', '\t', 'N', + '\x4', 'O', '\t', 'O', '\x4', 'P', '\t', 'P', '\x4', 'Q', '\t', 'Q', '\x4', + 'R', '\t', 'R', '\x4', 'S', '\t', 'S', '\x4', 'T', '\t', 'T', '\x4', 'U', + '\t', 'U', '\x4', 'V', '\t', 'V', '\x4', 'W', '\t', 'W', '\x4', 'X', '\t', + 'X', '\x4', 'Y', '\t', 'Y', '\x4', 'Z', '\t', 'Z', '\x4', '[', '\t', '[', + '\x4', '\\', '\t', '\\', '\x4', ']', '\t', ']', '\x4', '^', '\t', '^', + '\x4', '_', '\t', '_', '\x4', '`', '\t', '`', '\x4', '\x61', '\t', '\x61', + '\x4', '\x62', '\t', '\x62', '\x4', '\x63', '\t', '\x63', '\x4', '\x64', + '\t', '\x64', '\x4', '\x65', '\t', '\x65', '\x4', '\x66', '\t', '\x66', + '\x4', 'g', '\t', 'g', '\x4', 'h', '\t', 'h', '\x4', 'i', '\t', 'i', '\x4', + 'j', '\t', 'j', '\x4', 'k', '\t', 'k', '\x4', 'l', '\t', 'l', '\x4', 'm', + '\t', 'm', '\x4', 'n', '\t', 'n', '\x4', 'o', '\t', 'o', '\x4', 'p', '\t', + 'p', '\x4', 'q', '\t', 'q', '\x4', 'r', '\t', 'r', '\x4', 's', '\t', 's', + '\x4', 't', '\t', 't', '\x4', 'u', '\t', 'u', '\x4', 'v', '\t', 'v', '\x4', + 'w', '\t', 'w', '\x4', 'x', '\t', 'x', '\x4', 'y', '\t', 'y', '\x4', 'z', + '\t', 'z', '\x4', '{', '\t', '{', '\x4', '|', '\t', '|', '\x4', '}', '\t', + '}', '\x4', '~', '\t', '~', '\x4', '\x7F', '\t', '\x7F', '\x4', '\x80', + '\t', '\x80', '\x4', '\x81', '\t', '\x81', '\x4', '\x82', '\t', '\x82', + '\x4', '\x83', '\t', '\x83', '\x4', '\x84', '\t', '\x84', '\x4', '\x85', + '\t', '\x85', '\x4', '\x86', '\t', '\x86', '\x4', '\x87', '\t', '\x87', + '\x4', '\x88', '\t', '\x88', '\x4', '\x89', '\t', '\x89', '\x4', '\x8A', + '\t', '\x8A', '\x4', '\x8B', '\t', '\x8B', '\x4', '\x8C', '\t', '\x8C', + '\x4', '\x8D', '\t', '\x8D', '\x4', '\x8E', '\t', '\x8E', '\x4', '\x8F', + '\t', '\x8F', '\x4', '\x90', '\t', '\x90', '\x4', '\x91', '\t', '\x91', + '\x4', '\x92', '\t', '\x92', '\x4', '\x93', '\t', '\x93', '\x4', '\x94', + '\t', '\x94', '\x4', '\x95', '\t', '\x95', '\x4', '\x96', '\t', '\x96', + '\x4', '\x97', '\t', '\x97', '\x4', '\x98', '\t', '\x98', '\x4', '\x99', + '\t', '\x99', '\x4', '\x9A', '\t', '\x9A', '\x4', '\x9B', '\t', '\x9B', + '\x4', '\x9C', '\t', '\x9C', '\x4', '\x9D', '\t', '\x9D', '\x4', '\x9E', + '\t', '\x9E', '\x4', '\x9F', '\t', '\x9F', '\x4', '\xA0', '\t', '\xA0', + '\x4', '\xA1', '\t', '\xA1', '\x4', '\xA2', '\t', '\xA2', '\x4', '\xA3', + '\t', '\xA3', '\x4', '\xA4', '\t', '\xA4', '\x4', '\xA5', '\t', '\xA5', + '\x4', '\xA6', '\t', '\xA6', '\x4', '\xA7', '\t', '\xA7', '\x4', '\xA8', + '\t', '\xA8', '\x4', '\xA9', '\t', '\xA9', '\x4', '\xAA', '\t', '\xAA', + '\x4', '\xAB', '\t', '\xAB', '\x4', '\xAC', '\t', '\xAC', '\x4', '\xAD', + '\t', '\xAD', '\x4', '\xAE', '\t', '\xAE', '\x4', '\xAF', '\t', '\xAF', + '\x4', '\xB0', '\t', '\xB0', '\x4', '\xB1', '\t', '\xB1', '\x4', '\xB2', + '\t', '\xB2', '\x4', '\xB3', '\t', '\xB3', '\x4', '\xB4', '\t', '\xB4', + '\x4', '\xB5', '\t', '\xB5', '\x4', '\xB6', '\t', '\xB6', '\x4', '\xB7', + '\t', '\xB7', '\x4', '\xB8', '\t', '\xB8', '\x4', '\xB9', '\t', '\xB9', + '\x4', '\xBA', '\t', '\xBA', '\x4', '\xBB', '\t', '\xBB', '\x4', '\xBC', + '\t', '\xBC', '\x4', '\xBD', '\t', '\xBD', '\x4', '\xBE', '\t', '\xBE', + '\x4', '\xBF', '\t', '\xBF', '\x4', '\xC0', '\t', '\xC0', '\x4', '\xC1', + '\t', '\xC1', '\x4', '\xC2', '\t', '\xC2', '\x4', '\xC3', '\t', '\xC3', + '\x4', '\xC4', '\t', '\xC4', '\x4', '\xC5', '\t', '\xC5', '\x4', '\xC6', + '\t', '\xC6', '\x4', '\xC7', '\t', '\xC7', '\x4', '\xC8', '\t', '\xC8', + '\x4', '\xC9', '\t', '\xC9', '\x4', '\xCA', '\t', '\xCA', '\x4', '\xCB', + '\t', '\xCB', '\x4', '\xCC', '\t', '\xCC', '\x4', '\xCD', '\t', '\xCD', + '\x4', '\xCE', '\t', '\xCE', '\x4', '\xCF', '\t', '\xCF', '\x4', '\xD0', + '\t', '\xD0', '\x4', '\xD1', '\t', '\xD1', '\x4', '\xD2', '\t', '\xD2', + '\x4', '\xD3', '\t', '\xD3', '\x4', '\xD4', '\t', '\xD4', '\x4', '\xD5', + '\t', '\xD5', '\x4', '\xD6', '\t', '\xD6', '\x4', '\xD7', '\t', '\xD7', + '\x4', '\xD8', '\t', '\xD8', '\x4', '\xD9', '\t', '\xD9', '\x4', '\xDA', + '\t', '\xDA', '\x4', '\xDB', '\t', '\xDB', '\x4', '\xDC', '\t', '\xDC', + '\x4', '\xDD', '\t', '\xDD', '\x4', '\xDE', '\t', '\xDE', '\x4', '\xDF', + '\t', '\xDF', '\x4', '\xE0', '\t', '\xE0', '\x4', '\xE1', '\t', '\xE1', + '\x4', '\xE2', '\t', '\xE2', '\x4', '\xE3', '\t', '\xE3', '\x4', '\xE4', + '\t', '\xE4', '\x4', '\xE5', '\t', '\xE5', '\x4', '\xE6', '\t', '\xE6', + '\x4', '\xE7', '\t', '\xE7', '\x4', '\xE8', '\t', '\xE8', '\x4', '\xE9', + '\t', '\xE9', '\x4', '\xEA', '\t', '\xEA', '\x4', '\xEB', '\t', '\xEB', + '\x4', '\xEC', '\t', '\xEC', '\x4', '\xED', '\t', '\xED', '\x4', '\xEE', + '\t', '\xEE', '\x4', '\xEF', '\t', '\xEF', '\x4', '\xF0', '\t', '\xF0', + '\x4', '\xF1', '\t', '\xF1', '\x4', '\xF2', '\t', '\xF2', '\x4', '\xF3', + '\t', '\xF3', '\x4', '\xF4', '\t', '\xF4', '\x4', '\xF5', '\t', '\xF5', + '\x4', '\xF6', '\t', '\xF6', '\x3', '\x2', '\x3', '\x2', '\x3', '\x3', + '\a', '\x3', '\x1F0', '\n', '\x3', '\f', '\x3', '\xE', '\x3', '\x1F3', + '\v', '\x3', '\x3', '\x3', '\x3', '\x3', '\a', '\x3', '\x1F7', '\n', '\x3', + '\f', '\x3', '\xE', '\x3', '\x1FA', '\v', '\x3', '\x3', '\x3', '\x5', + '\x3', '\x1FD', '\n', '\x3', '\x3', '\x4', '\x3', '\x4', '\x5', '\x4', + '\x201', '\n', '\x4', '\x3', '\x5', '\x3', '\x5', '\x3', '\x6', '\x3', + '\x6', '\x3', '\a', '\x3', '\a', '\x3', '\a', '\x5', '\a', '\x20A', '\n', + '\a', '\x3', '\b', '\x3', '\b', '\x5', '\b', '\x20E', '\n', '\b', '\x3', + '\b', '\x3', '\b', '\a', '\b', '\x212', '\n', '\b', '\f', '\b', '\xE', + '\b', '\x215', '\v', '\b', '\x3', '\t', '\a', '\t', '\x218', '\n', '\t', + '\f', '\t', '\xE', '\t', '\x21B', '\v', '\t', '\x3', '\t', '\x3', '\t', + '\x5', '\t', '\x21F', '\n', '\t', '\x3', '\t', '\x3', '\t', '\x3', '\t', + '\a', '\t', '\x224', '\n', '\t', '\f', '\t', '\xE', '\t', '\x227', '\v', + '\t', '\x3', '\t', '\x3', '\t', '\x5', '\t', '\x22B', '\n', '\t', '\x5', + '\t', '\x22D', '\n', '\t', '\x3', '\n', '\x3', '\n', '\a', '\n', '\x231', + '\n', '\n', '\f', '\n', '\xE', '\n', '\x234', '\v', '\n', '\x3', '\n', + '\x3', '\n', '\x5', '\n', '\x238', '\n', '\n', '\x3', '\v', '\a', '\v', + '\x23B', '\n', '\v', '\f', '\v', '\xE', '\v', '\x23E', '\v', '\v', '\x3', + '\v', '\x3', '\v', '\x5', '\v', '\x242', '\n', '\v', '\x3', '\f', '\x3', + '\f', '\x3', '\r', '\x3', '\r', '\x3', '\xE', '\x3', '\xE', '\x3', '\xF', + '\a', '\xF', '\x24B', '\n', '\xF', '\f', '\xF', '\xE', '\xF', '\x24E', + '\v', '\xF', '\x3', '\xF', '\x3', '\xF', '\x3', '\x10', '\x3', '\x10', + '\x3', '\x10', '\x3', '\x10', '\x3', '\x10', '\x3', '\x10', '\x3', '\x10', + '\x3', '\x10', '\x3', '\x10', '\x5', '\x10', '\x25B', '\n', '\x10', '\x3', + '\x11', '\a', '\x11', '\x25E', '\n', '\x11', '\f', '\x11', '\xE', '\x11', + '\x261', '\v', '\x11', '\x3', '\x11', '\x3', '\x11', '\x3', '\x11', '\a', + '\x11', '\x266', '\n', '\x11', '\f', '\x11', '\xE', '\x11', '\x269', '\v', + '\x11', '\x3', '\x11', '\x3', '\x11', '\a', '\x11', '\x26D', '\n', '\x11', + '\f', '\x11', '\xE', '\x11', '\x270', '\v', '\x11', '\x3', '\x12', '\a', + '\x12', '\x273', '\n', '\x12', '\f', '\x12', '\xE', '\x12', '\x276', '\v', + '\x12', '\x3', '\x12', '\x3', '\x12', '\x5', '\x12', '\x27A', '\n', '\x12', + '\x3', '\x13', '\x3', '\x13', '\x3', '\x14', '\x3', '\x14', '\x3', '\x14', + '\x3', '\x14', '\x3', '\x14', '\a', '\x14', '\x283', '\n', '\x14', '\f', + '\x14', '\xE', '\x14', '\x286', '\v', '\x14', '\x5', '\x14', '\x288', + '\n', '\x14', '\x3', '\x15', '\x3', '\x15', '\x3', '\x15', '\x3', '\x16', + '\x3', '\x16', '\x3', '\x16', '\x3', '\x16', '\x3', '\x17', '\x3', '\x17', + '\x3', '\x17', '\a', '\x17', '\x294', '\n', '\x17', '\f', '\x17', '\xE', + '\x17', '\x297', '\v', '\x17', '\x3', '\x18', '\x3', '\x18', '\x5', '\x18', + '\x29B', '\n', '\x18', '\x3', '\x19', '\a', '\x19', '\x29E', '\n', '\x19', + '\f', '\x19', '\xE', '\x19', '\x2A1', '\v', '\x19', '\x3', '\x19', '\x3', + '\x19', '\x5', '\x19', '\x2A5', '\n', '\x19', '\x3', '\x1A', '\x3', '\x1A', + '\x3', '\x1A', '\x3', '\x1A', '\x5', '\x1A', '\x2AB', '\n', '\x1A', '\x3', + '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', + '\x1B', '\a', '\x1B', '\x2B3', '\n', '\x1B', '\f', '\x1B', '\xE', '\x1B', + '\x2B6', '\v', '\x1B', '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', + '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\a', '\x1C', '\x2BE', '\n', '\x1C', + '\f', '\x1C', '\xE', '\x1C', '\x2C1', '\v', '\x1C', '\x3', '\x1D', '\x3', + '\x1D', '\x3', '\x1D', '\x3', '\x1D', '\x3', '\x1D', '\x5', '\x1D', '\x2C8', + '\n', '\x1D', '\x3', '\x1E', '\x3', '\x1E', '\x3', '\x1E', '\x3', '\x1E', + '\x3', '\x1E', '\x3', '\x1E', '\a', '\x1E', '\x2D0', '\n', '\x1E', '\f', + '\x1E', '\xE', '\x1E', '\x2D3', '\v', '\x1E', '\x3', '\x1F', '\x3', '\x1F', + '\x3', '\x1F', '\x3', '\x1F', '\x3', '\x1F', '\x5', '\x1F', '\x2DA', '\n', + '\x1F', '\x3', ' ', '\x3', ' ', '\x3', '!', '\x3', '!', '\x3', '!', '\x3', + '!', '\x3', '!', '\x3', '!', '\a', '!', '\x2E4', '\n', '!', '\f', '!', + '\xE', '!', '\x2E7', '\v', '!', '\x3', '\"', '\x3', '\"', '\x5', '\"', + '\x2EB', '\n', '\"', '\x3', '#', '\x5', '#', '\x2EE', '\n', '#', '\x3', + '#', '\a', '#', '\x2F1', '\n', '#', '\f', '#', '\xE', '#', '\x2F4', '\v', + '#', '\x3', '#', '\a', '#', '\x2F7', '\n', '#', '\f', '#', '\xE', '#', + '\x2FA', '\v', '#', '\x3', '#', '\x3', '#', '\x3', '$', '\a', '$', '\x2FF', + '\n', '$', '\f', '$', '\xE', '$', '\x302', '\v', '$', '\x3', '$', '\x3', + '$', '\x3', '%', '\a', '%', '\x307', '\n', '%', '\f', '%', '\xE', '%', + '\x30A', '\v', '%', '\x3', '%', '\x3', '%', '\x3', '%', '\x3', '%', '\x3', + '&', '\x3', '&', '\x3', '\'', '\x3', '\'', '\x3', '\'', '\x3', '\'', '\x5', + '\'', '\x316', '\n', '\'', '\x3', '(', '\x3', '(', '\x3', '(', '\x3', + '(', '\x3', ')', '\x3', ')', '\x3', ')', '\x3', ')', '\x3', ')', '\x3', + ')', '\x3', '*', '\x3', '*', '\x3', '*', '\x3', '*', '\x3', '*', '\x3', + '*', '\x3', '*', '\x3', '+', '\x3', '+', '\x3', '+', '\x3', '+', '\x3', + '+', '\x3', '+', '\x3', '+', '\x3', ',', '\x3', ',', '\x3', ',', '\x5', + ',', '\x333', '\n', ',', '\x3', '-', '\a', '-', '\x336', '\n', '-', '\f', + '-', '\xE', '-', '\x339', '\v', '-', '\x3', '-', '\x5', '-', '\x33C', + '\n', '-', '\x3', '-', '\x3', '-', '\x3', '-', '\x3', '-', '\a', '-', + '\x342', '\n', '-', '\f', '-', '\xE', '-', '\x345', '\v', '-', '\x3', + '-', '\x3', '-', '\x3', '.', '\x3', '.', '\a', '.', '\x34B', '\n', '.', + '\f', '.', '\xE', '.', '\x34E', '\v', '.', '\x3', '.', '\x3', '.', '\x3', + '.', '\x3', '.', '\x3', '.', '\x3', '.', '\x3', '.', '\x3', '.', '\x3', + '.', '\a', '.', '\x359', '\n', '.', '\f', '.', '\xE', '.', '\x35C', '\v', + '.', '\x5', '.', '\x35E', '\n', '.', '\x3', '.', '\x3', '.', '\x3', '.', + '\x3', '.', '\x3', '.', '\x3', '.', '\x3', '.', '\x3', '.', '\a', '.', + '\x368', '\n', '.', '\f', '.', '\xE', '.', '\x36B', '\v', '.', '\x5', + '.', '\x36D', '\n', '.', '\x3', '.', '\x3', '.', '\x3', '.', '\x3', '.', + '\x3', '.', '\x3', '.', '\x3', '.', '\x3', '.', '\x3', '.', '\x3', '.', + '\x3', '.', '\x3', '.', '\a', '.', '\x37B', '\n', '.', '\f', '.', '\xE', + '.', '\x37E', '\v', '.', '\x3', '.', '\x3', '.', '\x5', '.', '\x382', + '\n', '.', '\x3', '/', '\x3', '/', '\x3', '\x30', '\x3', '\x30', '\x5', + '\x30', '\x388', '\n', '\x30', '\x3', '\x31', '\a', '\x31', '\x38B', '\n', + '\x31', '\f', '\x31', '\xE', '\x31', '\x38E', '\v', '\x31', '\x3', '\x31', + '\x3', '\x31', '\x3', '\x31', '\x5', '\x31', '\x393', '\n', '\x31', '\x3', + '\x31', '\x5', '\x31', '\x396', '\n', '\x31', '\x3', '\x31', '\x5', '\x31', + '\x399', '\n', '\x31', '\x3', '\x31', '\x3', '\x31', '\x3', '\x32', '\x3', + '\x32', '\x3', '\x32', '\x3', '\x32', '\x3', '\x32', '\x3', '\x32', '\x3', + '\x32', '\x3', '\x32', '\x5', '\x32', '\x3A5', '\n', '\x32', '\x3', '\x33', + '\x3', '\x33', '\x3', '\x33', '\x3', '\x33', '\x3', '\x34', '\x3', '\x34', + '\x3', '\x34', '\a', '\x34', '\x3AE', '\n', '\x34', '\f', '\x34', '\xE', + '\x34', '\x3B1', '\v', '\x34', '\x3', '\x35', '\x3', '\x35', '\x3', '\x35', + '\x3', '\x36', '\x3', '\x36', '\x3', '\x36', '\x3', '\x37', '\x3', '\x37', + '\x3', '\x37', '\a', '\x37', '\x3BC', '\n', '\x37', '\f', '\x37', '\xE', + '\x37', '\x3BF', '\v', '\x37', '\x3', '\x38', '\x3', '\x38', '\a', '\x38', + '\x3C3', '\n', '\x38', '\f', '\x38', '\xE', '\x38', '\x3C6', '\v', '\x38', + '\x3', '\x38', '\x3', '\x38', '\x3', '\x39', '\x3', '\x39', '\x3', '\x39', + '\x3', '\x39', '\x5', '\x39', '\x3CE', '\n', '\x39', '\x3', ':', '\x3', + ':', '\x3', ':', '\x3', ':', '\x3', ':', '\x5', ':', '\x3D5', '\n', ':', + '\x3', ';', '\a', ';', '\x3D8', '\n', ';', '\f', ';', '\xE', ';', '\x3DB', + '\v', ';', '\x3', ';', '\x3', ';', '\x3', ';', '\x3', ';', '\x3', '<', + '\x3', '<', '\x3', '<', '\x3', '<', '\x3', '<', '\x3', '<', '\x3', '<', + '\x3', '<', '\x5', '<', '\x3E9', '\n', '<', '\x3', '=', '\x3', '=', '\x3', + '=', '\a', '=', '\x3EE', '\n', '=', '\f', '=', '\xE', '=', '\x3F1', '\v', + '=', '\x3', '>', '\x3', '>', '\x3', '>', '\x5', '>', '\x3F6', '\n', '>', + '\x3', '?', '\x3', '?', '\x5', '?', '\x3FA', '\n', '?', '\x3', '@', '\x3', + '@', '\x5', '@', '\x3FE', '\n', '@', '\x3', '\x41', '\x3', '\x41', '\x5', + '\x41', '\x402', '\n', '\x41', '\x3', '\x42', '\x3', '\x42', '\x5', '\x42', + '\x406', '\n', '\x42', '\x3', '\x43', '\x3', '\x43', '\x3', '\x43', '\x5', + '\x43', '\x40B', '\n', '\x43', '\x3', '\x44', '\x3', '\x44', '\x5', '\x44', + '\x40F', '\n', '\x44', '\x3', '\x44', '\x3', '\x44', '\a', '\x44', '\x413', + '\n', '\x44', '\f', '\x44', '\xE', '\x44', '\x416', '\v', '\x44', '\x3', + '\x45', '\x3', '\x45', '\x5', '\x45', '\x41A', '\n', '\x45', '\x3', '\x45', + '\x3', '\x45', '\x3', '\x45', '\a', '\x45', '\x41F', '\n', '\x45', '\f', + '\x45', '\xE', '\x45', '\x422', '\v', '\x45', '\x3', '\x45', '\x3', '\x45', + '\x5', '\x45', '\x426', '\n', '\x45', '\x5', '\x45', '\x428', '\n', '\x45', + '\x3', '\x46', '\x3', '\x46', '\a', '\x46', '\x42C', '\n', '\x46', '\f', + '\x46', '\xE', '\x46', '\x42F', '\v', '\x46', '\x3', '\x46', '\x3', '\x46', + '\x5', '\x46', '\x433', '\n', '\x46', '\x3', 'G', '\x3', 'G', '\x5', 'G', + '\x437', '\n', 'G', '\x3', 'H', '\x3', 'H', '\x3', 'I', '\x3', 'I', '\x3', + 'J', '\x3', 'J', '\x3', 'K', '\x3', 'K', '\x3', 'L', '\x3', 'L', '\x3', + 'L', '\x3', 'L', '\x3', 'L', '\x3', 'L', '\x3', 'L', '\x3', 'L', '\x3', + 'L', '\x5', 'L', '\x44A', '\n', 'L', '\x3', 'M', '\a', 'M', '\x44D', '\n', + 'M', '\f', 'M', '\xE', 'M', '\x450', '\v', 'M', '\x3', 'M', '\x3', 'M', + '\x3', 'M', '\x3', 'N', '\x3', 'N', '\x3', 'N', '\x3', 'N', '\x3', 'N', + '\x3', 'N', '\x3', 'N', '\x3', 'N', '\x3', 'N', '\x3', 'N', '\x5', 'N', + '\x45F', '\n', 'N', '\x3', 'O', '\x3', 'O', '\x3', 'O', '\x5', 'O', '\x464', + '\n', 'O', '\x3', 'O', '\x3', 'O', '\a', 'O', '\x468', '\n', 'O', '\f', + 'O', '\xE', 'O', '\x46B', '\v', 'O', '\x3', 'O', '\x3', 'O', '\x3', 'O', + '\x5', 'O', '\x470', '\n', 'O', '\x5', 'O', '\x472', '\n', 'O', '\x3', + 'P', '\x3', 'P', '\x5', 'P', '\x476', '\n', 'P', '\x3', 'Q', '\x3', 'Q', + '\x3', 'Q', '\x5', 'Q', '\x47B', '\n', 'Q', '\x3', 'Q', '\x3', 'Q', '\x5', + 'Q', '\x47F', '\n', 'Q', '\x3', 'R', '\x3', 'R', '\x3', 'R', '\x3', 'R', + '\x3', 'R', '\x3', 'R', '\x5', 'R', '\x487', '\n', 'R', '\x3', 'S', '\x3', + 'S', '\x3', 'S', '\a', 'S', '\x48C', '\n', 'S', '\f', 'S', '\xE', 'S', + '\x48F', '\v', 'S', '\x3', 'S', '\x3', 'S', '\x3', 'S', '\a', 'S', '\x494', + '\n', 'S', '\f', 'S', '\xE', 'S', '\x497', '\v', 'S', '\x5', 'S', '\x499', + '\n', 'S', '\x3', 'T', '\a', 'T', '\x49C', '\n', 'T', '\f', 'T', '\xE', + 'T', '\x49F', '\v', 'T', '\x3', 'T', '\x3', 'T', '\x3', 'T', '\x3', 'U', + '\x3', 'U', '\x5', 'U', '\x4A6', '\n', 'U', '\x3', 'V', '\a', 'V', '\x4A9', + '\n', 'V', '\f', 'V', '\xE', 'V', '\x4AC', '\v', 'V', '\x3', 'V', '\x3', + 'V', '\a', 'V', '\x4B0', '\n', 'V', '\f', 'V', '\xE', 'V', '\x4B3', '\v', + 'V', '\x3', 'V', '\x3', 'V', '\x3', 'V', '\x3', 'V', '\x5', 'V', '\x4B9', + '\n', 'V', '\x3', 'W', '\a', 'W', '\x4BC', '\n', 'W', '\f', 'W', '\xE', + 'W', '\x4BF', '\v', 'W', '\x3', 'W', '\x3', 'W', '\x3', 'W', '\x3', 'W', + '\x5', 'W', '\x4C5', '\n', 'W', '\x3', 'W', '\x3', 'W', '\x3', 'X', '\x3', + 'X', '\x3', 'X', '\x3', 'Y', '\x3', 'Y', '\x3', 'Y', '\a', 'Y', '\x4CF', + '\n', 'Y', '\f', 'Y', '\xE', 'Y', '\x4D2', '\v', 'Y', '\x3', 'Z', '\x3', + 'Z', '\x5', 'Z', '\x4D6', '\n', 'Z', '\x3', '[', '\x3', '[', '\x5', '[', + '\x4DA', '\n', '[', '\x3', '\\', '\x3', '\\', '\x3', ']', '\x3', ']', + '\x3', ']', '\x3', '^', '\a', '^', '\x4E2', '\n', '^', '\f', '^', '\xE', + '^', '\x4E5', '\v', '^', '\x3', '^', '\x3', '^', '\x5', '^', '\x4E9', + '\n', '^', '\x3', '^', '\x3', '^', '\x3', '_', '\x3', '_', '\x3', '_', + '\x3', '_', '\x5', '_', '\x4F1', '\n', '_', '\x3', '`', '\x5', '`', '\x4F4', + '\n', '`', '\x3', '`', '\x3', '`', '\x3', '`', '\x5', '`', '\x4F9', '\n', + '`', '\x3', '`', '\x3', '`', '\x3', '\x61', '\x3', '\x61', '\x3', '\x62', + '\x3', '\x62', '\x5', '\x62', '\x501', '\n', '\x62', '\x3', '\x62', '\x5', + '\x62', '\x504', '\n', '\x62', '\x3', '\x62', '\x3', '\x62', '\x3', '\x63', + '\x5', '\x63', '\x509', '\n', '\x63', '\x3', '\x63', '\x3', '\x63', '\x3', + '\x63', '\x5', '\x63', '\x50E', '\n', '\x63', '\x3', '\x63', '\x3', '\x63', + '\x3', '\x63', '\x5', '\x63', '\x513', '\n', '\x63', '\x3', '\x63', '\x3', + '\x63', '\x3', '\x63', '\x5', '\x63', '\x518', '\n', '\x63', '\x3', '\x63', + '\x3', '\x63', '\x3', '\x63', '\x3', '\x63', '\x3', '\x63', '\x5', '\x63', + '\x51F', '\n', '\x63', '\x3', '\x63', '\x3', '\x63', '\x3', '\x63', '\x5', + '\x63', '\x524', '\n', '\x63', '\x3', '\x63', '\x3', '\x63', '\x3', '\x63', + '\x3', '\x63', '\x3', '\x63', '\x3', '\x63', '\x5', '\x63', '\x52C', '\n', + '\x63', '\x3', '\x63', '\x3', '\x63', '\x3', '\x63', '\x5', '\x63', '\x531', + '\n', '\x63', '\x3', '\x63', '\x3', '\x63', '\x3', '\x63', '\x5', '\x63', + '\x536', '\n', '\x63', '\x3', '\x64', '\a', '\x64', '\x539', '\n', '\x64', + '\f', '\x64', '\xE', '\x64', '\x53C', '\v', '\x64', '\x3', '\x64', '\x3', + '\x64', '\x3', '\x64', '\x5', '\x64', '\x541', '\n', '\x64', '\x3', '\x64', + '\x3', '\x64', '\x3', '\x65', '\x3', '\x65', '\x5', '\x65', '\x547', '\n', + '\x65', '\x3', '\x65', '\x5', '\x65', '\x54A', '\n', '\x65', '\x3', '\x65', + '\x5', '\x65', '\x54D', '\n', '\x65', '\x3', '\x65', '\x3', '\x65', '\x3', + '\x66', '\x3', '\x66', '\x3', '\x66', '\a', '\x66', '\x554', '\n', '\x66', + '\f', '\x66', '\xE', '\x66', '\x557', '\v', '\x66', '\x3', 'g', '\a', + 'g', '\x55A', '\n', 'g', '\f', 'g', '\xE', 'g', '\x55D', '\v', 'g', '\x3', + 'g', '\x3', 'g', '\x3', 'g', '\x5', 'g', '\x562', '\n', 'g', '\x3', 'g', + '\x5', 'g', '\x565', '\n', 'g', '\x3', 'g', '\x5', 'g', '\x568', '\n', + 'g', '\x3', 'h', '\x3', 'h', '\x3', 'i', '\x3', 'i', '\a', 'i', '\x56E', + '\n', 'i', '\f', 'i', '\xE', 'i', '\x571', '\v', 'i', '\x3', 'j', '\x3', + 'j', '\x5', 'j', '\x575', '\n', 'j', '\x3', 'k', '\a', 'k', '\x578', '\n', + 'k', '\f', 'k', '\xE', 'k', '\x57B', '\v', 'k', '\x3', 'k', '\x3', 'k', + '\x3', 'k', '\x5', 'k', '\x580', '\n', 'k', '\x3', 'k', '\x5', 'k', '\x583', + '\n', 'k', '\x3', 'k', '\x3', 'k', '\x3', 'l', '\x3', 'l', '\x3', 'l', + '\x3', 'l', '\x3', 'l', '\x3', 'l', '\x3', 'l', '\x5', 'l', '\x58E', '\n', + 'l', '\x3', 'm', '\x3', 'm', '\x3', 'm', '\x3', 'n', '\x3', 'n', '\a', + 'n', '\x595', '\n', 'n', '\f', 'n', '\xE', 'n', '\x598', '\v', 'n', '\x3', + 'n', '\x3', 'n', '\x3', 'o', '\x3', 'o', '\x3', 'o', '\x3', 'o', '\x3', + 'o', '\x5', 'o', '\x5A1', '\n', 'o', '\x3', 'p', '\a', 'p', '\x5A4', '\n', + 'p', '\f', 'p', '\xE', 'p', '\x5A7', '\v', 'p', '\x3', 'p', '\x3', 'p', + '\x3', 'p', '\x3', 'p', '\x3', 'q', '\x3', 'q', '\x3', 'q', '\x3', 'q', + '\x5', 'q', '\x5B1', '\n', 'q', '\x3', 'r', '\a', 'r', '\x5B4', '\n', + 'r', '\f', 'r', '\xE', 'r', '\x5B7', '\v', 'r', '\x3', 'r', '\x3', 'r', + '\x3', 'r', '\x3', 's', '\x3', 's', '\x3', 's', '\x3', 's', '\x3', 's', + '\x3', 's', '\x3', 's', '\x5', 's', '\x5C3', '\n', 's', '\x3', 't', '\a', + 't', '\x5C6', '\n', 't', '\f', 't', '\xE', 't', '\x5C9', '\v', 't', '\x3', + 't', '\x3', 't', '\x3', 't', '\x3', 't', '\x3', 't', '\x3', 'u', '\x3', + 'u', '\a', 'u', '\x5D2', '\n', 'u', '\f', 'u', '\xE', 'u', '\x5D5', '\v', + 'u', '\x3', 'u', '\x3', 'u', '\x3', 'v', '\x3', 'v', '\x3', 'v', '\x3', + 'v', '\x3', 'v', '\x5', 'v', '\x5DE', '\n', 'v', '\x3', 'w', '\a', 'w', + '\x5E1', '\n', 'w', '\f', 'w', '\xE', 'w', '\x5E4', '\v', 'w', '\x3', + 'w', '\x3', 'w', '\x3', 'w', '\x3', 'w', '\x3', 'w', '\x5', 'w', '\x5EB', + '\n', 'w', '\x3', 'w', '\x5', 'w', '\x5EE', '\n', 'w', '\x3', 'w', '\x3', + 'w', '\x3', 'x', '\x3', 'x', '\x3', 'x', '\x5', 'x', '\x5F5', '\n', 'x', + '\x3', 'y', '\x3', 'y', '\x3', 'y', '\x3', 'z', '\x3', 'z', '\x3', 'z', + '\x5', 'z', '\x5FD', '\n', 'z', '\x3', '{', '\x3', '{', '\x3', '{', '\x3', + '{', '\x5', '{', '\x603', '\n', '{', '\x3', '{', '\x3', '{', '\x3', '|', + '\x3', '|', '\x3', '|', '\a', '|', '\x60A', '\n', '|', '\f', '|', '\xE', + '|', '\x60D', '\v', '|', '\x3', '}', '\x3', '}', '\x3', '}', '\x3', '}', + '\x3', '~', '\x3', '~', '\x3', '~', '\x5', '~', '\x616', '\n', '~', '\x3', + '\x7F', '\x3', '\x7F', '\x5', '\x7F', '\x61A', '\n', '\x7F', '\x3', '\x7F', + '\x5', '\x7F', '\x61D', '\n', '\x7F', '\x3', '\x7F', '\x3', '\x7F', '\x3', + '\x80', '\x3', '\x80', '\x3', '\x80', '\a', '\x80', '\x624', '\n', '\x80', + '\f', '\x80', '\xE', '\x80', '\x627', '\v', '\x80', '\x3', '\x81', '\x3', + '\x81', '\x3', '\x81', '\x3', '\x82', '\x3', '\x82', '\x3', '\x82', '\x3', + '\x82', '\x3', '\x82', '\x3', '\x82', '\x3', '\x83', '\x3', '\x83', '\x5', + '\x83', '\x634', '\n', '\x83', '\x3', '\x83', '\x5', '\x83', '\x637', + '\n', '\x83', '\x3', '\x83', '\x3', '\x83', '\x3', '\x84', '\x3', '\x84', + '\x3', '\x84', '\a', '\x84', '\x63E', '\n', '\x84', '\f', '\x84', '\xE', + '\x84', '\x641', '\v', '\x84', '\x3', '\x85', '\x3', '\x85', '\x5', '\x85', + '\x645', '\n', '\x85', '\x3', '\x85', '\x3', '\x85', '\x3', '\x86', '\x6', + '\x86', '\x64A', '\n', '\x86', '\r', '\x86', '\xE', '\x86', '\x64B', '\x3', + '\x87', '\x3', '\x87', '\x3', '\x87', '\x5', '\x87', '\x651', '\n', '\x87', + '\x3', '\x88', '\x3', '\x88', '\x3', '\x88', '\x3', '\x89', '\a', '\x89', + '\x657', '\n', '\x89', '\f', '\x89', '\xE', '\x89', '\x65A', '\v', '\x89', + '\x3', '\x89', '\x3', '\x89', '\x3', '\x89', '\x3', '\x8A', '\x3', '\x8A', + '\x3', '\x8A', '\x3', '\x8A', '\x3', '\x8A', '\x3', '\x8A', '\x5', '\x8A', + '\x665', '\n', '\x8A', '\x3', '\x8B', '\x3', '\x8B', '\x3', '\x8B', '\x3', + '\x8B', '\x3', '\x8B', '\x5', '\x8B', '\x66C', '\n', '\x8B', '\x3', '\x8C', + '\x3', '\x8C', '\x3', '\x8C', '\x3', '\x8C', '\x3', '\x8C', '\x3', '\x8C', + '\x3', '\x8C', '\x3', '\x8C', '\x3', '\x8C', '\x3', '\x8C', '\x3', '\x8C', + '\x3', '\x8C', '\x5', '\x8C', '\x67A', '\n', '\x8C', '\x3', '\x8D', '\x3', + '\x8D', '\x3', '\x8E', '\x3', '\x8E', '\x3', '\x8E', '\x3', '\x8E', '\x3', + '\x8F', '\x3', '\x8F', '\x3', '\x8F', '\x3', '\x8F', '\x3', '\x90', '\x3', + '\x90', '\x3', '\x90', '\x3', '\x91', '\x3', '\x91', '\x3', '\x91', '\x3', + '\x91', '\x3', '\x91', '\x3', '\x91', '\x3', '\x91', '\x5', '\x91', '\x690', + '\n', '\x91', '\x3', '\x92', '\x3', '\x92', '\x3', '\x92', '\x3', '\x92', + '\x3', '\x92', '\x3', '\x92', '\x3', '\x93', '\x3', '\x93', '\x3', '\x93', + '\x3', '\x93', '\x3', '\x93', '\x3', '\x93', '\x3', '\x93', '\x3', '\x93', + '\x3', '\x94', '\x3', '\x94', '\x3', '\x94', '\x3', '\x94', '\x3', '\x94', + '\x3', '\x94', '\x3', '\x94', '\x3', '\x94', '\x3', '\x95', '\x3', '\x95', + '\x3', '\x95', '\x3', '\x95', '\x3', '\x95', '\x3', '\x95', '\x3', '\x95', + '\x3', '\x95', '\x3', '\x95', '\x3', '\x95', '\x5', '\x95', '\x6B2', '\n', + '\x95', '\x3', '\x96', '\x3', '\x96', '\x3', '\x96', '\x3', '\x96', '\x3', + '\x96', '\x3', '\x96', '\x3', '\x97', '\x3', '\x97', '\a', '\x97', '\x6BC', + '\n', '\x97', '\f', '\x97', '\xE', '\x97', '\x6BF', '\v', '\x97', '\x3', + '\x97', '\a', '\x97', '\x6C2', '\n', '\x97', '\f', '\x97', '\xE', '\x97', + '\x6C5', '\v', '\x97', '\x3', '\x97', '\x3', '\x97', '\x3', '\x98', '\x3', + '\x98', '\x3', '\x98', '\x3', '\x99', '\x6', '\x99', '\x6CD', '\n', '\x99', + '\r', '\x99', '\xE', '\x99', '\x6CE', '\x3', '\x9A', '\x3', '\x9A', '\x3', + '\x9A', '\x3', '\x9A', '\x3', '\x9A', '\x3', '\x9A', '\x3', '\x9A', '\x3', + '\x9A', '\x3', '\x9A', '\x3', '\x9A', '\x5', '\x9A', '\x6DB', '\n', '\x9A', + '\x3', '\x9B', '\x3', '\x9B', '\x3', '\x9C', '\x3', '\x9C', '\x3', '\x9C', + '\x3', '\x9C', '\x3', '\x9C', '\x3', '\x9C', '\x3', '\x9D', '\x3', '\x9D', + '\x3', '\x9D', '\x3', '\x9D', '\x3', '\x9D', '\x3', '\x9D', '\x3', '\x9E', + '\x3', '\x9E', '\x3', '\x9E', '\x3', '\x9E', '\x3', '\x9E', '\x3', '\x9E', + '\x3', '\x9E', '\x3', '\x9E', '\x3', '\x9F', '\x3', '\x9F', '\x5', '\x9F', + '\x6F5', '\n', '\x9F', '\x3', '\xA0', '\x3', '\xA0', '\x5', '\xA0', '\x6F9', + '\n', '\xA0', '\x3', '\xA1', '\x3', '\xA1', '\x3', '\xA1', '\x5', '\xA1', + '\x6FE', '\n', '\xA1', '\x3', '\xA1', '\x3', '\xA1', '\x5', '\xA1', '\x702', + '\n', '\xA1', '\x3', '\xA1', '\x3', '\xA1', '\x5', '\xA1', '\x706', '\n', + '\xA1', '\x3', '\xA1', '\x3', '\xA1', '\x3', '\xA1', '\x3', '\xA2', '\x3', + '\xA2', '\x3', '\xA2', '\x5', '\xA2', '\x70E', '\n', '\xA2', '\x3', '\xA2', + '\x3', '\xA2', '\x5', '\xA2', '\x712', '\n', '\xA2', '\x3', '\xA2', '\x3', + '\xA2', '\x5', '\xA2', '\x716', '\n', '\xA2', '\x3', '\xA2', '\x3', '\xA2', + '\x3', '\xA2', '\x3', '\xA3', '\x3', '\xA3', '\x5', '\xA3', '\x71D', '\n', + '\xA3', '\x3', '\xA4', '\x3', '\xA4', '\x3', '\xA5', '\x3', '\xA5', '\x3', + '\xA5', '\a', '\xA5', '\x724', '\n', '\xA5', '\f', '\xA5', '\xE', '\xA5', + '\x727', '\v', '\xA5', '\x3', '\xA6', '\x3', '\xA6', '\x3', '\xA6', '\a', + '\xA6', '\x72C', '\n', '\xA6', '\f', '\xA6', '\xE', '\xA6', '\x72F', '\v', + '\xA6', '\x3', '\xA6', '\x3', '\xA6', '\x3', '\xA6', '\x3', '\xA6', '\x3', + '\xA6', '\x3', '\xA6', '\x3', '\xA6', '\x3', '\xA7', '\x3', '\xA7', '\x3', + '\xA7', '\a', '\xA7', '\x73B', '\n', '\xA7', '\f', '\xA7', '\xE', '\xA7', + '\x73E', '\v', '\xA7', '\x3', '\xA7', '\x3', '\xA7', '\x3', '\xA7', '\x3', + '\xA7', '\x3', '\xA7', '\x3', '\xA7', '\x3', '\xA7', '\x3', '\xA8', '\x3', + '\xA8', '\x5', '\xA8', '\x749', '\n', '\xA8', '\x3', '\xA8', '\x3', '\xA8', + '\x3', '\xA9', '\x3', '\xA9', '\x5', '\xA9', '\x74F', '\n', '\xA9', '\x3', + '\xA9', '\x3', '\xA9', '\x3', '\xAA', '\x3', '\xAA', '\x5', '\xAA', '\x755', + '\n', '\xAA', '\x3', '\xAA', '\x3', '\xAA', '\x3', '\xAB', '\x3', '\xAB', + '\x3', '\xAB', '\x3', '\xAB', '\x3', '\xAC', '\x3', '\xAC', '\x3', '\xAC', + '\x3', '\xAC', '\x3', '\xAC', '\x3', '\xAC', '\x3', '\xAD', '\x3', '\xAD', + '\x3', '\xAD', '\x3', '\xAD', '\x3', '\xAD', '\x3', '\xAD', '\x3', '\xAD', + '\x5', '\xAD', '\x76A', '\n', '\xAD', '\x3', '\xAD', '\x3', '\xAD', '\x3', + '\xAD', '\x5', '\xAD', '\x76F', '\n', '\xAD', '\x3', '\xAE', '\x6', '\xAE', + '\x772', '\n', '\xAE', '\r', '\xAE', '\xE', '\xAE', '\x773', '\x3', '\xAF', + '\x3', '\xAF', '\x3', '\xAF', '\x3', '\xAF', '\x3', '\xAF', '\x3', '\xAF', + '\x3', '\xB0', '\a', '\xB0', '\x77D', '\n', '\xB0', '\f', '\xB0', '\xE', + '\xB0', '\x780', '\v', '\xB0', '\x3', '\xB0', '\x3', '\xB0', '\x3', '\xB0', + '\x3', '\xB1', '\x3', '\xB1', '\x3', '\xB1', '\a', '\xB1', '\x788', '\n', + '\xB1', '\f', '\xB1', '\xE', '\xB1', '\x78B', '\v', '\xB1', '\x3', '\xB2', + '\x3', '\xB2', '\x3', '\xB2', '\x3', '\xB3', '\x3', '\xB3', '\x3', '\xB3', + '\x3', '\xB3', '\x5', '\xB3', '\x794', '\n', '\xB3', '\x3', '\xB3', '\x5', + '\xB3', '\x797', '\n', '\xB3', '\x3', '\xB4', '\x3', '\xB4', '\x3', '\xB4', + '\x5', '\xB4', '\x79C', '\n', '\xB4', '\x3', '\xB4', '\x3', '\xB4', '\x3', + '\xB5', '\x3', '\xB5', '\x3', '\xB5', '\a', '\xB5', '\x7A3', '\n', '\xB5', + '\f', '\xB5', '\xE', '\xB5', '\x7A6', '\v', '\xB5', '\x3', '\xB6', '\a', + '\xB6', '\x7A9', '\n', '\xB6', '\f', '\xB6', '\xE', '\xB6', '\x7AC', '\v', + '\xB6', '\x3', '\xB6', '\x3', '\xB6', '\x3', '\xB6', '\x3', '\xB6', '\x3', + '\xB6', '\x3', '\xB6', '\x5', '\xB6', '\x7B4', '\n', '\xB6', '\x3', '\xB7', + '\x3', '\xB7', '\x5', '\xB7', '\x7B8', '\n', '\xB7', '\x3', '\xB8', '\x3', + '\xB8', '\x5', '\xB8', '\x7BC', '\n', '\xB8', '\x3', '\xB8', '\a', '\xB8', + '\x7BF', '\n', '\xB8', '\f', '\xB8', '\xE', '\xB8', '\x7C2', '\v', '\xB8', + '\x3', '\xB9', '\x3', '\xB9', '\x3', '\xB9', '\x3', '\xB9', '\x3', '\xB9', + '\x3', '\xB9', '\x3', '\xB9', '\x3', '\xB9', '\x3', '\xB9', '\x3', '\xB9', + '\x3', '\xB9', '\x3', '\xB9', '\x3', '\xB9', '\x3', '\xB9', '\x3', '\xB9', + '\x3', '\xB9', '\x5', '\xB9', '\x7D4', '\n', '\xB9', '\x3', '\xBA', '\x3', + '\xBA', '\x3', '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\a', + '\xBB', '\x7DC', '\n', '\xBB', '\f', '\xBB', '\xE', '\xBB', '\x7DF', '\v', + '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', + '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', + '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', + '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x3', '\xBB', '\x5', + '\xBB', '\x7F4', '\n', '\xBB', '\x3', '\xBC', '\x3', '\xBC', '\x3', '\xBC', + '\x3', '\xBC', '\x3', '\xBC', '\x5', '\xBC', '\x7FB', '\n', '\xBC', '\x3', + '\xBD', '\x3', '\xBD', '\x3', '\xBE', '\x3', '\xBE', '\x3', '\xBE', '\x3', + '\xBE', '\x5', '\xBE', '\x803', '\n', '\xBE', '\x3', '\xBF', '\x3', '\xBF', + '\x3', '\xBF', '\x3', '\xBF', '\a', '\xBF', '\x809', '\n', '\xBF', '\f', + '\xBF', '\xE', '\xBF', '\x80C', '\v', '\xBF', '\x3', '\xBF', '\x3', '\xBF', + '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', '\a', '\xBF', + '\x814', '\n', '\xBF', '\f', '\xBF', '\xE', '\xBF', '\x817', '\v', '\xBF', + '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', + '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', + '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', + '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', '\x3', '\xBF', + '\x5', '\xBF', '\x82D', '\n', '\xBF', '\x3', '\xC0', '\x3', '\xC0', '\x3', + '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\a', '\xC1', '\x835', + '\n', '\xC1', '\f', '\xC1', '\xE', '\xC1', '\x838', '\v', '\xC1', '\x3', + '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', + '\xC1', '\a', '\xC1', '\x840', '\n', '\xC1', '\f', '\xC1', '\xE', '\xC1', + '\x843', '\v', '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', + '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', + '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', + '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', '\xC1', '\x3', + '\xC1', '\x5', '\xC1', '\x858', '\n', '\xC1', '\x3', '\xC2', '\x3', '\xC2', + '\x3', '\xC2', '\x5', '\xC2', '\x85D', '\n', '\xC2', '\x3', '\xC2', '\x3', + '\xC2', '\a', '\xC2', '\x861', '\n', '\xC2', '\f', '\xC2', '\xE', '\xC2', + '\x864', '\v', '\xC2', '\x3', '\xC2', '\x3', '\xC2', '\x3', '\xC2', '\x3', + '\xC2', '\x3', '\xC2', '\x5', '\xC2', '\x86B', '\n', '\xC2', '\x3', '\xC3', + '\x3', '\xC3', '\x5', '\xC3', '\x86F', '\n', '\xC3', '\x3', '\xC3', '\a', + '\xC3', '\x872', '\n', '\xC3', '\f', '\xC3', '\xE', '\xC3', '\x875', '\v', + '\xC3', '\x3', '\xC3', '\x3', '\xC3', '\x3', '\xC3', '\a', '\xC3', '\x87A', + '\n', '\xC3', '\f', '\xC3', '\xE', '\xC3', '\x87D', '\v', '\xC3', '\x3', + '\xC3', '\a', '\xC3', '\x880', '\n', '\xC3', '\f', '\xC3', '\xE', '\xC3', + '\x883', '\v', '\xC3', '\x3', '\xC3', '\x5', '\xC3', '\x886', '\n', '\xC3', + '\x3', '\xC3', '\x3', '\xC3', '\x5', '\xC3', '\x88A', '\n', '\xC3', '\x3', + '\xC3', '\x3', '\xC3', '\x5', '\xC3', '\x88E', '\n', '\xC3', '\x3', '\xC3', + '\x3', '\xC3', '\x3', '\xC3', '\x3', '\xC3', '\x5', '\xC3', '\x894', '\n', + '\xC3', '\x3', '\xC3', '\a', '\xC3', '\x897', '\n', '\xC3', '\f', '\xC3', + '\xE', '\xC3', '\x89A', '\v', '\xC3', '\x3', '\xC3', '\x3', '\xC3', '\x5', + '\xC3', '\x89E', '\n', '\xC3', '\x3', '\xC3', '\x3', '\xC3', '\x5', '\xC3', + '\x8A2', '\n', '\xC3', '\x3', '\xC3', '\x3', '\xC3', '\x5', '\xC3', '\x8A6', + '\n', '\xC3', '\x3', '\xC3', '\x3', '\xC3', '\x3', '\xC3', '\x3', '\xC3', + '\x5', '\xC3', '\x8AC', '\n', '\xC3', '\x3', '\xC3', '\a', '\xC3', '\x8AF', + '\n', '\xC3', '\f', '\xC3', '\xE', '\xC3', '\x8B2', '\v', '\xC3', '\x3', + '\xC3', '\x3', '\xC3', '\x5', '\xC3', '\x8B6', '\n', '\xC3', '\x3', '\xC3', + '\x3', '\xC3', '\x5', '\xC3', '\x8BA', '\n', '\xC3', '\x3', '\xC3', '\x3', + '\xC3', '\x5', '\xC3', '\x8BE', '\n', '\xC3', '\x5', '\xC3', '\x8C0', + '\n', '\xC3', '\x3', '\xC4', '\x3', '\xC4', '\x3', '\xC4', '\x5', '\xC4', + '\x8C5', '\n', '\xC4', '\x3', '\xC4', '\a', '\xC4', '\x8C8', '\n', '\xC4', + '\f', '\xC4', '\xE', '\xC4', '\x8CB', '\v', '\xC4', '\x3', '\xC4', '\x3', + '\xC4', '\x5', '\xC4', '\x8CF', '\n', '\xC4', '\x3', '\xC4', '\x3', '\xC4', + '\x5', '\xC4', '\x8D3', '\n', '\xC4', '\x3', '\xC4', '\x3', '\xC4', '\x5', + '\xC4', '\x8D7', '\n', '\xC4', '\x3', '\xC5', '\x3', '\xC5', '\x5', '\xC5', + '\x8DB', '\n', '\xC5', '\x3', '\xC5', '\a', '\xC5', '\x8DE', '\n', '\xC5', + '\f', '\xC5', '\xE', '\xC5', '\x8E1', '\v', '\xC5', '\x3', '\xC5', '\x3', + '\xC5', '\x3', '\xC5', '\a', '\xC5', '\x8E6', '\n', '\xC5', '\f', '\xC5', + '\xE', '\xC5', '\x8E9', '\v', '\xC5', '\x3', '\xC5', '\a', '\xC5', '\x8EC', + '\n', '\xC5', '\f', '\xC5', '\xE', '\xC5', '\x8EF', '\v', '\xC5', '\x3', + '\xC5', '\x5', '\xC5', '\x8F2', '\n', '\xC5', '\x3', '\xC5', '\x3', '\xC5', + '\x5', '\xC5', '\x8F6', '\n', '\xC5', '\x3', '\xC5', '\x3', '\xC5', '\x5', + '\xC5', '\x8FA', '\n', '\xC5', '\x3', '\xC5', '\x3', '\xC5', '\x3', '\xC5', + '\x3', '\xC5', '\x5', '\xC5', '\x900', '\n', '\xC5', '\x3', '\xC5', '\a', + '\xC5', '\x903', '\n', '\xC5', '\f', '\xC5', '\xE', '\xC5', '\x906', '\v', + '\xC5', '\x3', '\xC5', '\x3', '\xC5', '\x5', '\xC5', '\x90A', '\n', '\xC5', + '\x3', '\xC5', '\x3', '\xC5', '\x5', '\xC5', '\x90E', '\n', '\xC5', '\x3', + '\xC5', '\x3', '\xC5', '\x5', '\xC5', '\x912', '\n', '\xC5', '\x5', '\xC5', + '\x914', '\n', '\xC5', '\x3', '\xC6', '\x3', '\xC6', '\x3', '\xC6', '\x5', + '\xC6', '\x919', '\n', '\xC6', '\x3', '\xC7', '\x3', '\xC7', '\x3', '\xC7', + '\x3', '\xC7', '\x3', '\xC7', '\x3', '\xC7', '\x3', '\xC7', '\x3', '\xC7', + '\x3', '\xC7', '\x3', '\xC7', '\x3', '\xC7', '\x3', '\xC7', '\x3', '\xC7', + '\x5', '\xC7', '\x928', '\n', '\xC7', '\x3', '\xC8', '\x3', '\xC8', '\x3', + '\xC8', '\x3', '\xC9', '\x3', '\xC9', '\x3', '\xC9', '\x3', '\xC9', '\x3', + '\xC9', '\x3', '\xC9', '\x3', '\xC9', '\x3', '\xC9', '\x3', '\xC9', '\x5', + '\xC9', '\x936', '\n', '\xC9', '\x3', '\xCA', '\x3', '\xCA', '\x3', '\xCA', + '\x3', '\xCA', '\x3', '\xCA', '\x3', '\xCA', '\x3', '\xCA', '\x3', '\xCA', + '\x3', '\xCA', '\x3', '\xCA', '\x5', '\xCA', '\x942', '\n', '\xCA', '\x3', + '\xCA', '\x3', '\xCA', '\x3', '\xCA', '\x3', '\xCA', '\x3', '\xCA', '\a', + '\xCA', '\x949', '\n', '\xCA', '\f', '\xCA', '\xE', '\xCA', '\x94C', '\v', + '\xCA', '\x3', '\xCB', '\x3', '\xCB', '\x3', '\xCB', '\x3', '\xCB', '\x3', + '\xCB', '\x3', '\xCB', '\x3', '\xCB', '\x3', '\xCB', '\x3', '\xCB', '\x3', + '\xCB', '\a', '\xCB', '\x958', '\n', '\xCB', '\f', '\xCB', '\xE', '\xCB', + '\x95B', '\v', '\xCB', '\x3', '\xCC', '\x3', '\xCC', '\x3', '\xCC', '\x3', + '\xCC', '\x3', '\xCC', '\x3', '\xCC', '\x3', '\xCC', '\x3', '\xCC', '\x3', + '\xCC', '\x3', '\xCC', '\x5', '\xCC', '\x967', '\n', '\xCC', '\x3', '\xCC', + '\x3', '\xCC', '\x3', '\xCC', '\x3', '\xCC', '\x3', '\xCC', '\a', '\xCC', + '\x96E', '\n', '\xCC', '\f', '\xCC', '\xE', '\xCC', '\x971', '\v', '\xCC', + '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x5', '\xCD', '\x976', '\n', + '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', + '\xCD', '\x5', '\xCD', '\x97D', '\n', '\xCD', '\x3', '\xCD', '\x3', '\xCD', + '\x3', '\xCD', '\x5', '\xCD', '\x982', '\n', '\xCD', '\x3', '\xCD', '\x3', + '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x5', '\xCD', '\x989', + '\n', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x5', '\xCD', + '\x98E', '\n', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', + '\xCD', '\x3', '\xCD', '\x5', '\xCD', '\x995', '\n', '\xCD', '\x3', '\xCD', + '\x3', '\xCD', '\x3', '\xCD', '\x5', '\xCD', '\x99A', '\n', '\xCD', '\x3', + '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x5', + '\xCD', '\x9A1', '\n', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', + '\x5', '\xCD', '\x9A6', '\n', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', + '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x5', + '\xCD', '\x9AF', '\n', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x3', '\xCD', + '\x5', '\xCD', '\x9B4', '\n', '\xCD', '\x3', '\xCD', '\x3', '\xCD', '\x5', + '\xCD', '\x9B8', '\n', '\xCD', '\x3', '\xCE', '\x3', '\xCE', '\x5', '\xCE', + '\x9BC', '\n', '\xCE', '\x3', '\xCE', '\x3', '\xCE', '\x3', '\xCE', '\x5', + '\xCE', '\x9C1', '\n', '\xCE', '\x3', '\xCE', '\x3', '\xCE', '\x3', '\xCF', + '\x3', '\xCF', '\x3', '\xCF', '\x5', '\xCF', '\x9C8', '\n', '\xCF', '\x3', + '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x5', + '\xCF', '\x9CF', '\n', '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x3', '\xCF', + '\x5', '\xCF', '\x9D4', '\n', '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x3', + '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x5', '\xCF', '\x9DB', '\n', '\xCF', + '\x3', '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x5', '\xCF', '\x9E0', '\n', + '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x3', + '\xCF', '\x5', '\xCF', '\x9E7', '\n', '\xCF', '\x3', '\xCF', '\x3', '\xCF', + '\x3', '\xCF', '\x5', '\xCF', '\x9EC', '\n', '\xCF', '\x3', '\xCF', '\x3', + '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x3', '\xCF', '\x3', + '\xCF', '\x5', '\xCF', '\x9F5', '\n', '\xCF', '\x3', '\xCF', '\x3', '\xCF', + '\x3', '\xCF', '\x5', '\xCF', '\x9FA', '\n', '\xCF', '\x3', '\xCF', '\x3', + '\xCF', '\x5', '\xCF', '\x9FE', '\n', '\xCF', '\x3', '\xD0', '\x3', '\xD0', + '\x3', '\xD0', '\a', '\xD0', '\xA03', '\n', '\xD0', '\f', '\xD0', '\xE', + '\xD0', '\xA06', '\v', '\xD0', '\x3', '\xD1', '\x3', '\xD1', '\x3', '\xD1', + '\x5', '\xD1', '\xA0B', '\n', '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x3', + '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x5', '\xD1', '\xA12', '\n', '\xD1', + '\x3', '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x3', '\xD1', + '\x5', '\xD1', '\xA19', '\n', '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x3', + '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x5', '\xD1', '\xA20', '\n', '\xD1', + '\x3', '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x3', '\xD1', + '\x3', '\xD1', '\x5', '\xD1', '\xA28', '\n', '\xD1', '\x3', '\xD1', '\x3', + '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x5', '\xD1', '\xA2F', + '\n', '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x3', '\xD1', '\x3', '\xD1', + '\x3', '\xD1', '\x3', '\xD1', '\x5', '\xD1', '\xA37', '\n', '\xD1', '\x3', + '\xD2', '\x3', '\xD2', '\x5', '\xD2', '\xA3B', '\n', '\xD2', '\x3', '\xD2', + '\x3', '\xD2', '\x3', '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x5', '\xD3', + '\xA42', '\n', '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x3', + '\xD3', '\x3', '\xD3', '\x5', '\xD3', '\xA49', '\n', '\xD3', '\x3', '\xD3', + '\x3', '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x5', '\xD3', + '\xA50', '\n', '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x3', + '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x5', '\xD3', '\xA58', '\n', '\xD3', + '\x3', '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x3', '\xD3', + '\x5', '\xD3', '\xA5F', '\n', '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x3', + '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x3', '\xD3', '\x5', '\xD3', '\xA67', + '\n', '\xD3', '\x3', '\xD4', '\x3', '\xD4', '\x3', '\xD4', '\x3', '\xD4', + '\x5', '\xD4', '\xA6D', '\n', '\xD4', '\x3', '\xD4', '\x3', '\xD4', '\x3', + '\xD4', '\x3', '\xD4', '\x5', '\xD4', '\xA73', '\n', '\xD4', '\x3', '\xD4', + '\x3', '\xD4', '\x3', '\xD4', '\x3', '\xD4', '\x3', '\xD4', '\x3', '\xD4', + '\x3', '\xD4', '\x3', '\xD4', '\x3', '\xD4', '\x3', '\xD4', '\x5', '\xD4', + '\xA7F', '\n', '\xD4', '\x3', '\xD5', '\x6', '\xD5', '\xA82', '\n', '\xD5', + '\r', '\xD5', '\xE', '\xD5', '\xA83', '\x3', '\xD6', '\a', '\xD6', '\xA87', + '\n', '\xD6', '\f', '\xD6', '\xE', '\xD6', '\xA8A', '\v', '\xD6', '\x3', + '\xD6', '\x3', '\xD6', '\x3', '\xD6', '\x3', '\xD6', '\x3', '\xD7', '\x3', + '\xD7', '\x3', '\xD8', '\x3', '\xD8', '\x5', '\xD8', '\xA94', '\n', '\xD8', + '\x3', '\xD9', '\x3', '\xD9', '\x3', '\xD9', '\x3', '\xD9', '\x3', '\xDA', + '\x3', '\xDA', '\x3', '\xDA', '\x5', '\xDA', '\xA9D', '\n', '\xDA', '\x3', + '\xDA', '\x3', '\xDA', '\x3', '\xDA', '\x3', '\xDA', '\x3', '\xDA', '\x5', + '\xDA', '\xAA4', '\n', '\xDA', '\x3', '\xDB', '\x3', '\xDB', '\x3', '\xDB', + '\a', '\xDB', '\xAA9', '\n', '\xDB', '\f', '\xDB', '\xE', '\xDB', '\xAAC', + '\v', '\xDB', '\x3', '\xDC', '\x3', '\xDC', '\x5', '\xDC', '\xAB0', '\n', + '\xDC', '\x3', '\xDD', '\x3', '\xDD', '\x5', '\xDD', '\xAB4', '\n', '\xDD', + '\x3', '\xDE', '\x3', '\xDE', '\x3', '\xDE', '\x3', '\xDE', '\x3', '\xDF', + '\x3', '\xDF', '\x3', '\xDF', '\x5', '\xDF', '\xABD', '\n', '\xDF', '\x3', + '\xE0', '\x3', '\xE0', '\x3', '\xE1', '\x3', '\xE1', '\x3', '\xE1', '\x3', + '\xE1', '\x3', '\xE1', '\x3', '\xE1', '\x3', '\xE1', '\x5', '\xE1', '\xAC8', + '\n', '\xE1', '\x5', '\xE1', '\xACA', '\n', '\xE1', '\x3', '\xE2', '\x3', + '\xE2', '\x3', '\xE2', '\x3', '\xE2', '\x3', '\xE2', '\x3', '\xE2', '\a', + '\xE2', '\xAD2', '\n', '\xE2', '\f', '\xE2', '\xE', '\xE2', '\xAD5', '\v', + '\xE2', '\x3', '\xE3', '\x3', '\xE3', '\x3', '\xE3', '\x3', '\xE3', '\x3', + '\xE3', '\x3', '\xE3', '\a', '\xE3', '\xADD', '\n', '\xE3', '\f', '\xE3', + '\xE', '\xE3', '\xAE0', '\v', '\xE3', '\x3', '\xE4', '\x3', '\xE4', '\x3', + '\xE4', '\x3', '\xE4', '\x3', '\xE4', '\x3', '\xE4', '\a', '\xE4', '\xAE8', + '\n', '\xE4', '\f', '\xE4', '\xE', '\xE4', '\xAEB', '\v', '\xE4', '\x3', + '\xE5', '\x3', '\xE5', '\x3', '\xE5', '\x3', '\xE5', '\x3', '\xE5', '\x3', + '\xE5', '\a', '\xE5', '\xAF3', '\n', '\xE5', '\f', '\xE5', '\xE', '\xE5', + '\xAF6', '\v', '\xE5', '\x3', '\xE6', '\x3', '\xE6', '\x3', '\xE6', '\x3', + '\xE6', '\x3', '\xE6', '\x3', '\xE6', '\a', '\xE6', '\xAFE', '\n', '\xE6', + '\f', '\xE6', '\xE', '\xE6', '\xB01', '\v', '\xE6', '\x3', '\xE7', '\x3', + '\xE7', '\x3', '\xE7', '\x3', '\xE7', '\x3', '\xE7', '\x3', '\xE7', '\x3', + '\xE7', '\x3', '\xE7', '\x3', '\xE7', '\a', '\xE7', '\xB0C', '\n', '\xE7', + '\f', '\xE7', '\xE', '\xE7', '\xB0F', '\v', '\xE7', '\x3', '\xE8', '\x3', + '\xE8', '\x3', '\xE8', '\x3', '\xE8', '\x3', '\xE8', '\x3', '\xE8', '\x3', + '\xE8', '\x3', '\xE8', '\x3', '\xE8', '\x3', '\xE8', '\x3', '\xE8', '\x3', + '\xE8', '\x3', '\xE8', '\x3', '\xE8', '\x3', '\xE8', '\x3', '\xE8', '\x3', + '\xE8', '\x3', '\xE8', '\a', '\xE8', '\xB23', '\n', '\xE8', '\f', '\xE8', + '\xE', '\xE8', '\xB26', '\v', '\xE8', '\x3', '\xE9', '\x3', '\xE9', '\x3', + '\xE9', '\x3', '\xE9', '\x3', '\xE9', '\x3', '\xE9', '\x3', '\xE9', '\x3', + '\xE9', '\x3', '\xE9', '\x3', '\xE9', '\x3', '\xE9', '\x3', '\xE9', '\x3', + '\xE9', '\x3', '\xE9', '\x3', '\xE9', '\x3', '\xE9', '\x3', '\xE9', '\x3', + '\xE9', '\a', '\xE9', '\xB3A', '\n', '\xE9', '\f', '\xE9', '\xE', '\xE9', + '\xB3D', '\v', '\xE9', '\x3', '\xEA', '\x3', '\xEA', '\x3', '\xEA', '\x3', + '\xEA', '\x3', '\xEA', '\x3', '\xEA', '\x3', '\xEA', '\x3', '\xEA', '\x3', + '\xEA', '\a', '\xEA', '\xB48', '\n', '\xEA', '\f', '\xEA', '\xE', '\xEA', + '\xB4B', '\v', '\xEA', '\x3', '\xEB', '\x3', '\xEB', '\x3', '\xEB', '\x3', + '\xEB', '\x3', '\xEB', '\x3', '\xEB', '\x3', '\xEB', '\x3', '\xEB', '\x3', + '\xEB', '\x3', '\xEB', '\x3', '\xEB', '\x3', '\xEB', '\a', '\xEB', '\xB59', + '\n', '\xEB', '\f', '\xEB', '\xE', '\xEB', '\xB5C', '\v', '\xEB', '\x3', + '\xEC', '\x3', '\xEC', '\x3', '\xEC', '\x3', '\xEC', '\x3', '\xEC', '\x3', + '\xEC', '\x3', '\xEC', '\x5', '\xEC', '\xB65', '\n', '\xEC', '\x3', '\xED', + '\x3', '\xED', '\x3', '\xED', '\x3', '\xEE', '\x3', '\xEE', '\x3', '\xEE', + '\x3', '\xEF', '\x3', '\xEF', '\x3', '\xEF', '\x3', '\xEF', '\x3', '\xEF', + '\x3', '\xEF', '\x5', '\xEF', '\xB73', '\n', '\xEF', '\x3', '\xF0', '\x3', + '\xF0', '\x5', '\xF0', '\xB77', '\n', '\xF0', '\x3', '\xF0', '\x3', '\xF0', + '\a', '\xF0', '\xB7B', '\n', '\xF0', '\f', '\xF0', '\xE', '\xF0', '\xB7E', + '\v', '\xF0', '\x3', '\xF1', '\x3', '\xF1', '\x3', '\xF1', '\x3', '\xF2', + '\x3', '\xF2', '\x3', '\xF3', '\x3', '\xF3', '\x3', '\xF3', '\x3', '\xF4', + '\x3', '\xF4', '\x3', '\xF5', '\x3', '\xF5', '\x3', '\xF5', '\x3', '\xF5', + '\x3', '\xF5', '\x3', '\xF5', '\x3', '\xF5', '\x3', '\xF5', '\a', '\xF5', + '\xB92', '\n', '\xF5', '\f', '\xF5', '\xE', '\xF5', '\xB95', '\v', '\xF5', + '\x3', '\xF5', '\x3', '\xF5', '\x3', '\xF5', '\x3', '\xF5', '\x3', '\xF5', + '\x3', '\xF5', '\a', '\xF5', '\xB9D', '\n', '\xF5', '\f', '\xF5', '\xE', + '\xF5', '\xBA0', '\v', '\xF5', '\x3', '\xF5', '\x3', '\xF5', '\x3', '\xF5', + '\x5', '\xF5', '\xBA5', '\n', '\xF5', '\x3', '\xF6', '\x3', '\xF6', '\x3', + '\xF6', '\x2', '\x10', '\x34', '\x36', ':', '@', '\x1C2', '\x1C4', '\x1C6', + '\x1C8', '\x1CA', '\x1CC', '\x1CE', '\x1D0', '\x1D2', '\x1D4', '\xF7', + '\x2', '\x4', '\x6', '\b', '\n', '\f', '\xE', '\x10', '\x12', '\x14', + '\x16', '\x18', '\x1A', '\x1C', '\x1E', ' ', '\"', '$', '&', '(', '*', + ',', '.', '\x30', '\x32', '\x34', '\x36', '\x38', ':', '<', '>', '@', + '\x42', '\x44', '\x46', 'H', 'J', 'L', 'N', 'P', 'R', 'T', 'V', 'X', 'Z', + '\\', '^', '`', '\x62', '\x64', '\x66', 'h', 'j', 'l', 'n', 'p', 'r', + 't', 'v', 'x', 'z', '|', '~', '\x80', '\x82', '\x84', '\x86', '\x88', + '\x8A', '\x8C', '\x8E', '\x90', '\x92', '\x94', '\x96', '\x98', '\x9A', + '\x9C', '\x9E', '\xA0', '\xA2', '\xA4', '\xA6', '\xA8', '\xAA', '\xAC', + '\xAE', '\xB0', '\xB2', '\xB4', '\xB6', '\xB8', '\xBA', '\xBC', '\xBE', + '\xC0', '\xC2', '\xC4', '\xC6', '\xC8', '\xCA', '\xCC', '\xCE', '\xD0', + '\xD2', '\xD4', '\xD6', '\xD8', '\xDA', '\xDC', '\xDE', '\xE0', '\xE2', + '\xE4', '\xE6', '\xE8', '\xEA', '\xEC', '\xEE', '\xF0', '\xF2', '\xF4', + '\xF6', '\xF8', '\xFA', '\xFC', '\xFE', '\x100', '\x102', '\x104', '\x106', + '\x108', '\x10A', '\x10C', '\x10E', '\x110', '\x112', '\x114', '\x116', + '\x118', '\x11A', '\x11C', '\x11E', '\x120', '\x122', '\x124', '\x126', + '\x128', '\x12A', '\x12C', '\x12E', '\x130', '\x132', '\x134', '\x136', + '\x138', '\x13A', '\x13C', '\x13E', '\x140', '\x142', '\x144', '\x146', + '\x148', '\x14A', '\x14C', '\x14E', '\x150', '\x152', '\x154', '\x156', + '\x158', '\x15A', '\x15C', '\x15E', '\x160', '\x162', '\x164', '\x166', + '\x168', '\x16A', '\x16C', '\x16E', '\x170', '\x172', '\x174', '\x176', + '\x178', '\x17A', '\x17C', '\x17E', '\x180', '\x182', '\x184', '\x186', + '\x188', '\x18A', '\x18C', '\x18E', '\x190', '\x192', '\x194', '\x196', + '\x198', '\x19A', '\x19C', '\x19E', '\x1A0', '\x1A2', '\x1A4', '\x1A6', + '\x1A8', '\x1AA', '\x1AC', '\x1AE', '\x1B0', '\x1B2', '\x1B4', '\x1B6', + '\x1B8', '\x1BA', '\x1BC', '\x1BE', '\x1C0', '\x1C2', '\x1C4', '\x1C6', + '\x1C8', '\x1CA', '\x1CC', '\x1CE', '\x1D0', '\x1D2', '\x1D4', '\x1D6', + '\x1D8', '\x1DA', '\x1DC', '\x1DE', '\x1E0', '\x1E2', '\x1E4', '\x1E6', + '\x1E8', '\x1EA', '\x2', '\b', '\x3', '\x2', '@', '\x45', '\a', '\x2', + '\a', '\a', '\n', '\n', '\x1E', '\x1E', ' ', ' ', '-', '-', '\x4', '\x2', + '\x10', '\x10', '\x17', '\x17', '\x4', '\x2', '.', '.', '\x38', '\x38', + '\x4', '\x2', 'R', 'R', 'j', 't', '\v', '\x2', '\x13', '\x13', '!', '!', + '$', '%', ')', ')', '+', '+', '\x36', '\x36', ':', ':', '>', '>', 'u', + 'u', '\x2', '\xCA7', '\x2', '\x1EC', '\x3', '\x2', '\x2', '\x2', '\x4', + '\x1FC', '\x3', '\x2', '\x2', '\x2', '\x6', '\x200', '\x3', '\x2', '\x2', + '\x2', '\b', '\x202', '\x3', '\x2', '\x2', '\x2', '\n', '\x204', '\x3', + '\x2', '\x2', '\x2', '\f', '\x209', '\x3', '\x2', '\x2', '\x2', '\xE', + '\x20D', '\x3', '\x2', '\x2', '\x2', '\x10', '\x22C', '\x3', '\x2', '\x2', + '\x2', '\x12', '\x22E', '\x3', '\x2', '\x2', '\x2', '\x14', '\x23C', '\x3', + '\x2', '\x2', '\x2', '\x16', '\x243', '\x3', '\x2', '\x2', '\x2', '\x18', + '\x245', '\x3', '\x2', '\x2', '\x2', '\x1A', '\x247', '\x3', '\x2', '\x2', + '\x2', '\x1C', '\x24C', '\x3', '\x2', '\x2', '\x2', '\x1E', '\x25A', '\x3', + '\x2', '\x2', '\x2', ' ', '\x25F', '\x3', '\x2', '\x2', '\x2', '\"', '\x274', + '\x3', '\x2', '\x2', '\x2', '$', '\x27B', '\x3', '\x2', '\x2', '\x2', + '&', '\x287', '\x3', '\x2', '\x2', '\x2', '(', '\x289', '\x3', '\x2', + '\x2', '\x2', '*', '\x28C', '\x3', '\x2', '\x2', '\x2', ',', '\x290', + '\x3', '\x2', '\x2', '\x2', '.', '\x29A', '\x3', '\x2', '\x2', '\x2', + '\x30', '\x29F', '\x3', '\x2', '\x2', '\x2', '\x32', '\x2AA', '\x3', '\x2', + '\x2', '\x2', '\x34', '\x2AC', '\x3', '\x2', '\x2', '\x2', '\x36', '\x2B7', + '\x3', '\x2', '\x2', '\x2', '\x38', '\x2C7', '\x3', '\x2', '\x2', '\x2', + ':', '\x2C9', '\x3', '\x2', '\x2', '\x2', '<', '\x2D9', '\x3', '\x2', + '\x2', '\x2', '>', '\x2DB', '\x3', '\x2', '\x2', '\x2', '@', '\x2DD', + '\x3', '\x2', '\x2', '\x2', '\x42', '\x2EA', '\x3', '\x2', '\x2', '\x2', + '\x44', '\x2ED', '\x3', '\x2', '\x2', '\x2', '\x46', '\x300', '\x3', '\x2', + '\x2', '\x2', 'H', '\x308', '\x3', '\x2', '\x2', '\x2', 'J', '\x30F', + '\x3', '\x2', '\x2', '\x2', 'L', '\x315', '\x3', '\x2', '\x2', '\x2', + 'N', '\x317', '\x3', '\x2', '\x2', '\x2', 'P', '\x31B', '\x3', '\x2', + '\x2', '\x2', 'R', '\x321', '\x3', '\x2', '\x2', '\x2', 'T', '\x328', + '\x3', '\x2', '\x2', '\x2', 'V', '\x332', '\x3', '\x2', '\x2', '\x2', + 'X', '\x337', '\x3', '\x2', '\x2', '\x2', 'Z', '\x381', '\x3', '\x2', + '\x2', '\x2', '\\', '\x383', '\x3', '\x2', '\x2', '\x2', '^', '\x387', + '\x3', '\x2', '\x2', '\x2', '`', '\x38C', '\x3', '\x2', '\x2', '\x2', + '\x62', '\x3A4', '\x3', '\x2', '\x2', '\x2', '\x64', '\x3A6', '\x3', '\x2', + '\x2', '\x2', '\x66', '\x3AA', '\x3', '\x2', '\x2', '\x2', 'h', '\x3B2', + '\x3', '\x2', '\x2', '\x2', 'j', '\x3B5', '\x3', '\x2', '\x2', '\x2', + 'l', '\x3B8', '\x3', '\x2', '\x2', '\x2', 'n', '\x3C0', '\x3', '\x2', + '\x2', '\x2', 'p', '\x3CD', '\x3', '\x2', '\x2', '\x2', 'r', '\x3D4', + '\x3', '\x2', '\x2', '\x2', 't', '\x3D9', '\x3', '\x2', '\x2', '\x2', + 'v', '\x3E8', '\x3', '\x2', '\x2', '\x2', 'x', '\x3EA', '\x3', '\x2', + '\x2', '\x2', 'z', '\x3F2', '\x3', '\x2', '\x2', '\x2', '|', '\x3F7', + '\x3', '\x2', '\x2', '\x2', '~', '\x3FD', '\x3', '\x2', '\x2', '\x2', + '\x80', '\x401', '\x3', '\x2', '\x2', '\x2', '\x82', '\x405', '\x3', '\x2', + '\x2', '\x2', '\x84', '\x40A', '\x3', '\x2', '\x2', '\x2', '\x86', '\x40E', + '\x3', '\x2', '\x2', '\x2', '\x88', '\x427', '\x3', '\x2', '\x2', '\x2', + '\x8A', '\x429', '\x3', '\x2', '\x2', '\x2', '\x8C', '\x434', '\x3', '\x2', + '\x2', '\x2', '\x8E', '\x438', '\x3', '\x2', '\x2', '\x2', '\x90', '\x43A', + '\x3', '\x2', '\x2', '\x2', '\x92', '\x43C', '\x3', '\x2', '\x2', '\x2', + '\x94', '\x43E', '\x3', '\x2', '\x2', '\x2', '\x96', '\x449', '\x3', '\x2', + '\x2', '\x2', '\x98', '\x44E', '\x3', '\x2', '\x2', '\x2', '\x9A', '\x45E', + '\x3', '\x2', '\x2', '\x2', '\x9C', '\x471', '\x3', '\x2', '\x2', '\x2', + '\x9E', '\x475', '\x3', '\x2', '\x2', '\x2', '\xA0', '\x477', '\x3', '\x2', + '\x2', '\x2', '\xA2', '\x486', '\x3', '\x2', '\x2', '\x2', '\xA4', '\x498', + '\x3', '\x2', '\x2', '\x2', '\xA6', '\x49D', '\x3', '\x2', '\x2', '\x2', + '\xA8', '\x4A5', '\x3', '\x2', '\x2', '\x2', '\xAA', '\x4B8', '\x3', '\x2', + '\x2', '\x2', '\xAC', '\x4BD', '\x3', '\x2', '\x2', '\x2', '\xAE', '\x4C8', + '\x3', '\x2', '\x2', '\x2', '\xB0', '\x4CB', '\x3', '\x2', '\x2', '\x2', + '\xB2', '\x4D5', '\x3', '\x2', '\x2', '\x2', '\xB4', '\x4D9', '\x3', '\x2', + '\x2', '\x2', '\xB6', '\x4DB', '\x3', '\x2', '\x2', '\x2', '\xB8', '\x4DD', + '\x3', '\x2', '\x2', '\x2', '\xBA', '\x4E3', '\x3', '\x2', '\x2', '\x2', + '\xBC', '\x4F0', '\x3', '\x2', '\x2', '\x2', '\xBE', '\x4F3', '\x3', '\x2', + '\x2', '\x2', '\xC0', '\x4FC', '\x3', '\x2', '\x2', '\x2', '\xC2', '\x4FE', + '\x3', '\x2', '\x2', '\x2', '\xC4', '\x535', '\x3', '\x2', '\x2', '\x2', + '\xC6', '\x53A', '\x3', '\x2', '\x2', '\x2', '\xC8', '\x544', '\x3', '\x2', + '\x2', '\x2', '\xCA', '\x550', '\x3', '\x2', '\x2', '\x2', '\xCC', '\x55B', + '\x3', '\x2', '\x2', '\x2', '\xCE', '\x569', '\x3', '\x2', '\x2', '\x2', + '\xD0', '\x56B', '\x3', '\x2', '\x2', '\x2', '\xD2', '\x574', '\x3', '\x2', + '\x2', '\x2', '\xD4', '\x579', '\x3', '\x2', '\x2', '\x2', '\xD6', '\x58D', + '\x3', '\x2', '\x2', '\x2', '\xD8', '\x58F', '\x3', '\x2', '\x2', '\x2', + '\xDA', '\x592', '\x3', '\x2', '\x2', '\x2', '\xDC', '\x5A0', '\x3', '\x2', + '\x2', '\x2', '\xDE', '\x5A5', '\x3', '\x2', '\x2', '\x2', '\xE0', '\x5B0', + '\x3', '\x2', '\x2', '\x2', '\xE2', '\x5B5', '\x3', '\x2', '\x2', '\x2', + '\xE4', '\x5C2', '\x3', '\x2', '\x2', '\x2', '\xE6', '\x5C7', '\x3', '\x2', + '\x2', '\x2', '\xE8', '\x5CF', '\x3', '\x2', '\x2', '\x2', '\xEA', '\x5DD', + '\x3', '\x2', '\x2', '\x2', '\xEC', '\x5E2', '\x3', '\x2', '\x2', '\x2', + '\xEE', '\x5F4', '\x3', '\x2', '\x2', '\x2', '\xF0', '\x5F6', '\x3', '\x2', + '\x2', '\x2', '\xF2', '\x5FC', '\x3', '\x2', '\x2', '\x2', '\xF4', '\x5FE', + '\x3', '\x2', '\x2', '\x2', '\xF6', '\x606', '\x3', '\x2', '\x2', '\x2', + '\xF8', '\x60E', '\x3', '\x2', '\x2', '\x2', '\xFA', '\x615', '\x3', '\x2', + '\x2', '\x2', '\xFC', '\x617', '\x3', '\x2', '\x2', '\x2', '\xFE', '\x620', + '\x3', '\x2', '\x2', '\x2', '\x100', '\x628', '\x3', '\x2', '\x2', '\x2', + '\x102', '\x62B', '\x3', '\x2', '\x2', '\x2', '\x104', '\x631', '\x3', + '\x2', '\x2', '\x2', '\x106', '\x63A', '\x3', '\x2', '\x2', '\x2', '\x108', + '\x642', '\x3', '\x2', '\x2', '\x2', '\x10A', '\x649', '\x3', '\x2', '\x2', + '\x2', '\x10C', '\x650', '\x3', '\x2', '\x2', '\x2', '\x10E', '\x652', + '\x3', '\x2', '\x2', '\x2', '\x110', '\x658', '\x3', '\x2', '\x2', '\x2', + '\x112', '\x664', '\x3', '\x2', '\x2', '\x2', '\x114', '\x66B', '\x3', + '\x2', '\x2', '\x2', '\x116', '\x679', '\x3', '\x2', '\x2', '\x2', '\x118', + '\x67B', '\x3', '\x2', '\x2', '\x2', '\x11A', '\x67D', '\x3', '\x2', '\x2', + '\x2', '\x11C', '\x681', '\x3', '\x2', '\x2', '\x2', '\x11E', '\x685', + '\x3', '\x2', '\x2', '\x2', '\x120', '\x68F', '\x3', '\x2', '\x2', '\x2', + '\x122', '\x691', '\x3', '\x2', '\x2', '\x2', '\x124', '\x697', '\x3', + '\x2', '\x2', '\x2', '\x126', '\x69F', '\x3', '\x2', '\x2', '\x2', '\x128', + '\x6B1', '\x3', '\x2', '\x2', '\x2', '\x12A', '\x6B3', '\x3', '\x2', '\x2', + '\x2', '\x12C', '\x6B9', '\x3', '\x2', '\x2', '\x2', '\x12E', '\x6C8', + '\x3', '\x2', '\x2', '\x2', '\x130', '\x6CC', '\x3', '\x2', '\x2', '\x2', + '\x132', '\x6DA', '\x3', '\x2', '\x2', '\x2', '\x134', '\x6DC', '\x3', + '\x2', '\x2', '\x2', '\x136', '\x6DE', '\x3', '\x2', '\x2', '\x2', '\x138', + '\x6E4', '\x3', '\x2', '\x2', '\x2', '\x13A', '\x6EA', '\x3', '\x2', '\x2', + '\x2', '\x13C', '\x6F4', '\x3', '\x2', '\x2', '\x2', '\x13E', '\x6F8', + '\x3', '\x2', '\x2', '\x2', '\x140', '\x6FA', '\x3', '\x2', '\x2', '\x2', + '\x142', '\x70A', '\x3', '\x2', '\x2', '\x2', '\x144', '\x71C', '\x3', + '\x2', '\x2', '\x2', '\x146', '\x71E', '\x3', '\x2', '\x2', '\x2', '\x148', + '\x720', '\x3', '\x2', '\x2', '\x2', '\x14A', '\x728', '\x3', '\x2', '\x2', + '\x2', '\x14C', '\x737', '\x3', '\x2', '\x2', '\x2', '\x14E', '\x746', + '\x3', '\x2', '\x2', '\x2', '\x150', '\x74C', '\x3', '\x2', '\x2', '\x2', + '\x152', '\x752', '\x3', '\x2', '\x2', '\x2', '\x154', '\x758', '\x3', + '\x2', '\x2', '\x2', '\x156', '\x75C', '\x3', '\x2', '\x2', '\x2', '\x158', + '\x76E', '\x3', '\x2', '\x2', '\x2', '\x15A', '\x771', '\x3', '\x2', '\x2', + '\x2', '\x15C', '\x775', '\x3', '\x2', '\x2', '\x2', '\x15E', '\x77E', + '\x3', '\x2', '\x2', '\x2', '\x160', '\x784', '\x3', '\x2', '\x2', '\x2', + '\x162', '\x78C', '\x3', '\x2', '\x2', '\x2', '\x164', '\x78F', '\x3', + '\x2', '\x2', '\x2', '\x166', '\x798', '\x3', '\x2', '\x2', '\x2', '\x168', + '\x79F', '\x3', '\x2', '\x2', '\x2', '\x16A', '\x7B3', '\x3', '\x2', '\x2', + '\x2', '\x16C', '\x7B7', '\x3', '\x2', '\x2', '\x2', '\x16E', '\x7BB', + '\x3', '\x2', '\x2', '\x2', '\x170', '\x7D3', '\x3', '\x2', '\x2', '\x2', + '\x172', '\x7D5', '\x3', '\x2', '\x2', '\x2', '\x174', '\x7F3', '\x3', + '\x2', '\x2', '\x2', '\x176', '\x7FA', '\x3', '\x2', '\x2', '\x2', '\x178', + '\x7FC', '\x3', '\x2', '\x2', '\x2', '\x17A', '\x802', '\x3', '\x2', '\x2', + '\x2', '\x17C', '\x82C', '\x3', '\x2', '\x2', '\x2', '\x17E', '\x82E', + '\x3', '\x2', '\x2', '\x2', '\x180', '\x857', '\x3', '\x2', '\x2', '\x2', + '\x182', '\x86A', '\x3', '\x2', '\x2', '\x2', '\x184', '\x8BF', '\x3', + '\x2', '\x2', '\x2', '\x186', '\x8C1', '\x3', '\x2', '\x2', '\x2', '\x188', + '\x913', '\x3', '\x2', '\x2', '\x2', '\x18A', '\x918', '\x3', '\x2', '\x2', + '\x2', '\x18C', '\x927', '\x3', '\x2', '\x2', '\x2', '\x18E', '\x929', + '\x3', '\x2', '\x2', '\x2', '\x190', '\x935', '\x3', '\x2', '\x2', '\x2', + '\x192', '\x941', '\x3', '\x2', '\x2', '\x2', '\x194', '\x94D', '\x3', + '\x2', '\x2', '\x2', '\x196', '\x966', '\x3', '\x2', '\x2', '\x2', '\x198', + '\x9B7', '\x3', '\x2', '\x2', '\x2', '\x19A', '\x9B9', '\x3', '\x2', '\x2', + '\x2', '\x19C', '\x9FD', '\x3', '\x2', '\x2', '\x2', '\x19E', '\x9FF', + '\x3', '\x2', '\x2', '\x2', '\x1A0', '\xA36', '\x3', '\x2', '\x2', '\x2', + '\x1A2', '\xA38', '\x3', '\x2', '\x2', '\x2', '\x1A4', '\xA66', '\x3', + '\x2', '\x2', '\x2', '\x1A6', '\xA7E', '\x3', '\x2', '\x2', '\x2', '\x1A8', + '\xA81', '\x3', '\x2', '\x2', '\x2', '\x1AA', '\xA88', '\x3', '\x2', '\x2', + '\x2', '\x1AC', '\xA8F', '\x3', '\x2', '\x2', '\x2', '\x1AE', '\xA93', + '\x3', '\x2', '\x2', '\x2', '\x1B0', '\xA95', '\x3', '\x2', '\x2', '\x2', + '\x1B2', '\xAA3', '\x3', '\x2', '\x2', '\x2', '\x1B4', '\xAA5', '\x3', + '\x2', '\x2', '\x2', '\x1B6', '\xAAF', '\x3', '\x2', '\x2', '\x2', '\x1B8', + '\xAB3', '\x3', '\x2', '\x2', '\x2', '\x1BA', '\xAB5', '\x3', '\x2', '\x2', + '\x2', '\x1BC', '\xABC', '\x3', '\x2', '\x2', '\x2', '\x1BE', '\xABE', + '\x3', '\x2', '\x2', '\x2', '\x1C0', '\xAC9', '\x3', '\x2', '\x2', '\x2', + '\x1C2', '\xACB', '\x3', '\x2', '\x2', '\x2', '\x1C4', '\xAD6', '\x3', + '\x2', '\x2', '\x2', '\x1C6', '\xAE1', '\x3', '\x2', '\x2', '\x2', '\x1C8', + '\xAEC', '\x3', '\x2', '\x2', '\x2', '\x1CA', '\xAF7', '\x3', '\x2', '\x2', + '\x2', '\x1CC', '\xB02', '\x3', '\x2', '\x2', '\x2', '\x1CE', '\xB10', + '\x3', '\x2', '\x2', '\x2', '\x1D0', '\xB27', '\x3', '\x2', '\x2', '\x2', + '\x1D2', '\xB3E', '\x3', '\x2', '\x2', '\x2', '\x1D4', '\xB4C', '\x3', + '\x2', '\x2', '\x2', '\x1D6', '\xB64', '\x3', '\x2', '\x2', '\x2', '\x1D8', + '\xB66', '\x3', '\x2', '\x2', '\x2', '\x1DA', '\xB69', '\x3', '\x2', '\x2', + '\x2', '\x1DC', '\xB72', '\x3', '\x2', '\x2', '\x2', '\x1DE', '\xB76', + '\x3', '\x2', '\x2', '\x2', '\x1E0', '\xB7F', '\x3', '\x2', '\x2', '\x2', + '\x1E2', '\xB82', '\x3', '\x2', '\x2', '\x2', '\x1E4', '\xB84', '\x3', + '\x2', '\x2', '\x2', '\x1E6', '\xB87', '\x3', '\x2', '\x2', '\x2', '\x1E8', + '\xBA4', '\x3', '\x2', '\x2', '\x2', '\x1EA', '\xBA6', '\x3', '\x2', '\x2', + '\x2', '\x1EC', '\x1ED', '\t', '\x2', '\x2', '\x2', '\x1ED', '\x3', '\x3', + '\x2', '\x2', '\x2', '\x1EE', '\x1F0', '\x5', '\xF2', 'z', '\x2', '\x1EF', + '\x1EE', '\x3', '\x2', '\x2', '\x2', '\x1F0', '\x1F3', '\x3', '\x2', '\x2', + '\x2', '\x1F1', '\x1EF', '\x3', '\x2', '\x2', '\x2', '\x1F1', '\x1F2', + '\x3', '\x2', '\x2', '\x2', '\x1F2', '\x1F4', '\x3', '\x2', '\x2', '\x2', + '\x1F3', '\x1F1', '\x3', '\x2', '\x2', '\x2', '\x1F4', '\x1FD', '\x5', + '\x6', '\x4', '\x2', '\x1F5', '\x1F7', '\x5', '\xF2', 'z', '\x2', '\x1F6', + '\x1F5', '\x3', '\x2', '\x2', '\x2', '\x1F7', '\x1FA', '\x3', '\x2', '\x2', + '\x2', '\x1F8', '\x1F6', '\x3', '\x2', '\x2', '\x2', '\x1F8', '\x1F9', + '\x3', '\x2', '\x2', '\x2', '\x1F9', '\x1FB', '\x3', '\x2', '\x2', '\x2', + '\x1FA', '\x1F8', '\x3', '\x2', '\x2', '\x2', '\x1FB', '\x1FD', '\a', + '\x5', '\x2', '\x2', '\x1FC', '\x1F1', '\x3', '\x2', '\x2', '\x2', '\x1FC', + '\x1F8', '\x3', '\x2', '\x2', '\x2', '\x1FD', '\x5', '\x3', '\x2', '\x2', + '\x2', '\x1FE', '\x201', '\x5', '\b', '\x5', '\x2', '\x1FF', '\x201', + '\x5', '\n', '\x6', '\x2', '\x200', '\x1FE', '\x3', '\x2', '\x2', '\x2', + '\x200', '\x1FF', '\x3', '\x2', '\x2', '\x2', '\x201', '\a', '\x3', '\x2', + '\x2', '\x2', '\x202', '\x203', '\t', '\x3', '\x2', '\x2', '\x203', '\t', + '\x3', '\x2', '\x2', '\x2', '\x204', '\x205', '\t', '\x4', '\x2', '\x2', + '\x205', '\v', '\x3', '\x2', '\x2', '\x2', '\x206', '\x20A', '\x5', '\xE', + '\b', '\x2', '\x207', '\x20A', '\x5', '\x1C', '\xF', '\x2', '\x208', '\x20A', + '\x5', '\x1E', '\x10', '\x2', '\x209', '\x206', '\x3', '\x2', '\x2', '\x2', + '\x209', '\x207', '\x3', '\x2', '\x2', '\x2', '\x209', '\x208', '\x3', + '\x2', '\x2', '\x2', '\x20A', '\r', '\x3', '\x2', '\x2', '\x2', '\x20B', + '\x20E', '\x5', '\x14', '\v', '\x2', '\x20C', '\x20E', '\x5', '\x1A', + '\xE', '\x2', '\x20D', '\x20B', '\x3', '\x2', '\x2', '\x2', '\x20D', '\x20C', + '\x3', '\x2', '\x2', '\x2', '\x20E', '\x213', '\x3', '\x2', '\x2', '\x2', + '\x20F', '\x212', '\x5', '\x12', '\n', '\x2', '\x210', '\x212', '\x5', + '\x18', '\r', '\x2', '\x211', '\x20F', '\x3', '\x2', '\x2', '\x2', '\x211', + '\x210', '\x3', '\x2', '\x2', '\x2', '\x212', '\x215', '\x3', '\x2', '\x2', + '\x2', '\x213', '\x211', '\x3', '\x2', '\x2', '\x2', '\x213', '\x214', + '\x3', '\x2', '\x2', '\x2', '\x214', '\xF', '\x3', '\x2', '\x2', '\x2', + '\x215', '\x213', '\x3', '\x2', '\x2', '\x2', '\x216', '\x218', '\x5', + '\xF2', 'z', '\x2', '\x217', '\x216', '\x3', '\x2', '\x2', '\x2', '\x218', + '\x21B', '\x3', '\x2', '\x2', '\x2', '\x219', '\x217', '\x3', '\x2', '\x2', + '\x2', '\x219', '\x21A', '\x3', '\x2', '\x2', '\x2', '\x21A', '\x21C', + '\x3', '\x2', '\x2', '\x2', '\x21B', '\x219', '\x3', '\x2', '\x2', '\x2', + '\x21C', '\x21E', '\x5', '\x1EA', '\xF6', '\x2', '\x21D', '\x21F', '\x5', + '*', '\x16', '\x2', '\x21E', '\x21D', '\x3', '\x2', '\x2', '\x2', '\x21E', + '\x21F', '\x3', '\x2', '\x2', '\x2', '\x21F', '\x22D', '\x3', '\x2', '\x2', + '\x2', '\x220', '\x221', '\x5', '\xE', '\b', '\x2', '\x221', '\x225', + '\a', 'N', '\x2', '\x2', '\x222', '\x224', '\x5', '\xF2', 'z', '\x2', + '\x223', '\x222', '\x3', '\x2', '\x2', '\x2', '\x224', '\x227', '\x3', + '\x2', '\x2', '\x2', '\x225', '\x223', '\x3', '\x2', '\x2', '\x2', '\x225', + '\x226', '\x3', '\x2', '\x2', '\x2', '\x226', '\x228', '\x3', '\x2', '\x2', + '\x2', '\x227', '\x225', '\x3', '\x2', '\x2', '\x2', '\x228', '\x22A', + '\x5', '\x1EA', '\xF6', '\x2', '\x229', '\x22B', '\x5', '*', '\x16', '\x2', + '\x22A', '\x229', '\x3', '\x2', '\x2', '\x2', '\x22A', '\x22B', '\x3', + '\x2', '\x2', '\x2', '\x22B', '\x22D', '\x3', '\x2', '\x2', '\x2', '\x22C', + '\x219', '\x3', '\x2', '\x2', '\x2', '\x22C', '\x220', '\x3', '\x2', '\x2', + '\x2', '\x22D', '\x11', '\x3', '\x2', '\x2', '\x2', '\x22E', '\x232', + '\a', 'N', '\x2', '\x2', '\x22F', '\x231', '\x5', '\xF2', 'z', '\x2', + '\x230', '\x22F', '\x3', '\x2', '\x2', '\x2', '\x231', '\x234', '\x3', + '\x2', '\x2', '\x2', '\x232', '\x230', '\x3', '\x2', '\x2', '\x2', '\x232', + '\x233', '\x3', '\x2', '\x2', '\x2', '\x233', '\x235', '\x3', '\x2', '\x2', + '\x2', '\x234', '\x232', '\x3', '\x2', '\x2', '\x2', '\x235', '\x237', + '\x5', '\x1EA', '\xF6', '\x2', '\x236', '\x238', '\x5', '*', '\x16', '\x2', + '\x237', '\x236', '\x3', '\x2', '\x2', '\x2', '\x237', '\x238', '\x3', + '\x2', '\x2', '\x2', '\x238', '\x13', '\x3', '\x2', '\x2', '\x2', '\x239', + '\x23B', '\x5', '\xF2', 'z', '\x2', '\x23A', '\x239', '\x3', '\x2', '\x2', + '\x2', '\x23B', '\x23E', '\x3', '\x2', '\x2', '\x2', '\x23C', '\x23A', + '\x3', '\x2', '\x2', '\x2', '\x23C', '\x23D', '\x3', '\x2', '\x2', '\x2', + '\x23D', '\x23F', '\x3', '\x2', '\x2', '\x2', '\x23E', '\x23C', '\x3', + '\x2', '\x2', '\x2', '\x23F', '\x241', '\x5', '\x1EA', '\xF6', '\x2', + '\x240', '\x242', '\x5', '*', '\x16', '\x2', '\x241', '\x240', '\x3', + '\x2', '\x2', '\x2', '\x241', '\x242', '\x3', '\x2', '\x2', '\x2', '\x242', + '\x15', '\x3', '\x2', '\x2', '\x2', '\x243', '\x244', '\x5', '\x10', '\t', + '\x2', '\x244', '\x17', '\x3', '\x2', '\x2', '\x2', '\x245', '\x246', + '\x5', '\x12', '\n', '\x2', '\x246', '\x19', '\x3', '\x2', '\x2', '\x2', + '\x247', '\x248', '\x5', '\x14', '\v', '\x2', '\x248', '\x1B', '\x3', + '\x2', '\x2', '\x2', '\x249', '\x24B', '\x5', '\xF2', 'z', '\x2', '\x24A', + '\x249', '\x3', '\x2', '\x2', '\x2', '\x24B', '\x24E', '\x3', '\x2', '\x2', + '\x2', '\x24C', '\x24A', '\x3', '\x2', '\x2', '\x2', '\x24C', '\x24D', + '\x3', '\x2', '\x2', '\x2', '\x24D', '\x24F', '\x3', '\x2', '\x2', '\x2', + '\x24E', '\x24C', '\x3', '\x2', '\x2', '\x2', '\x24F', '\x250', '\x5', + '\x1EA', '\xF6', '\x2', '\x250', '\x1D', '\x3', '\x2', '\x2', '\x2', '\x251', + '\x252', '\x5', '\x4', '\x3', '\x2', '\x252', '\x253', '\x5', ' ', '\x11', + '\x2', '\x253', '\x25B', '\x3', '\x2', '\x2', '\x2', '\x254', '\x255', + '\x5', '\xE', '\b', '\x2', '\x255', '\x256', '\x5', ' ', '\x11', '\x2', + '\x256', '\x25B', '\x3', '\x2', '\x2', '\x2', '\x257', '\x258', '\x5', + '\x1C', '\xF', '\x2', '\x258', '\x259', '\x5', ' ', '\x11', '\x2', '\x259', + '\x25B', '\x3', '\x2', '\x2', '\x2', '\x25A', '\x251', '\x3', '\x2', '\x2', + '\x2', '\x25A', '\x254', '\x3', '\x2', '\x2', '\x2', '\x25A', '\x257', + '\x3', '\x2', '\x2', '\x2', '\x25B', '\x1F', '\x3', '\x2', '\x2', '\x2', + '\x25C', '\x25E', '\x5', '\xF2', 'z', '\x2', '\x25D', '\x25C', '\x3', + '\x2', '\x2', '\x2', '\x25E', '\x261', '\x3', '\x2', '\x2', '\x2', '\x25F', + '\x25D', '\x3', '\x2', '\x2', '\x2', '\x25F', '\x260', '\x3', '\x2', '\x2', + '\x2', '\x260', '\x262', '\x3', '\x2', '\x2', '\x2', '\x261', '\x25F', + '\x3', '\x2', '\x2', '\x2', '\x262', '\x263', '\a', 'J', '\x2', '\x2', + '\x263', '\x26E', '\a', 'K', '\x2', '\x2', '\x264', '\x266', '\x5', '\xF2', + 'z', '\x2', '\x265', '\x264', '\x3', '\x2', '\x2', '\x2', '\x266', '\x269', + '\x3', '\x2', '\x2', '\x2', '\x267', '\x265', '\x3', '\x2', '\x2', '\x2', + '\x267', '\x268', '\x3', '\x2', '\x2', '\x2', '\x268', '\x26A', '\x3', + '\x2', '\x2', '\x2', '\x269', '\x267', '\x3', '\x2', '\x2', '\x2', '\x26A', + '\x26B', '\a', 'J', '\x2', '\x2', '\x26B', '\x26D', '\a', 'K', '\x2', + '\x2', '\x26C', '\x267', '\x3', '\x2', '\x2', '\x2', '\x26D', '\x270', + '\x3', '\x2', '\x2', '\x2', '\x26E', '\x26C', '\x3', '\x2', '\x2', '\x2', + '\x26E', '\x26F', '\x3', '\x2', '\x2', '\x2', '\x26F', '!', '\x3', '\x2', + '\x2', '\x2', '\x270', '\x26E', '\x3', '\x2', '\x2', '\x2', '\x271', '\x273', + '\x5', '$', '\x13', '\x2', '\x272', '\x271', '\x3', '\x2', '\x2', '\x2', + '\x273', '\x276', '\x3', '\x2', '\x2', '\x2', '\x274', '\x272', '\x3', + '\x2', '\x2', '\x2', '\x274', '\x275', '\x3', '\x2', '\x2', '\x2', '\x275', + '\x277', '\x3', '\x2', '\x2', '\x2', '\x276', '\x274', '\x3', '\x2', '\x2', + '\x2', '\x277', '\x279', '\x5', '\x1EA', '\xF6', '\x2', '\x278', '\x27A', + '\x5', '&', '\x14', '\x2', '\x279', '\x278', '\x3', '\x2', '\x2', '\x2', + '\x279', '\x27A', '\x3', '\x2', '\x2', '\x2', '\x27A', '#', '\x3', '\x2', + '\x2', '\x2', '\x27B', '\x27C', '\x5', '\xF2', 'z', '\x2', '\x27C', '%', + '\x3', '\x2', '\x2', '\x2', '\x27D', '\x27E', '\a', '\x14', '\x2', '\x2', + '\x27E', '\x288', '\x5', '\x1C', '\xF', '\x2', '\x27F', '\x280', '\a', + '\x14', '\x2', '\x2', '\x280', '\x284', '\x5', '\xE', '\b', '\x2', '\x281', + '\x283', '\x5', '(', '\x15', '\x2', '\x282', '\x281', '\x3', '\x2', '\x2', + '\x2', '\x283', '\x286', '\x3', '\x2', '\x2', '\x2', '\x284', '\x282', + '\x3', '\x2', '\x2', '\x2', '\x284', '\x285', '\x3', '\x2', '\x2', '\x2', + '\x285', '\x288', '\x3', '\x2', '\x2', '\x2', '\x286', '\x284', '\x3', + '\x2', '\x2', '\x2', '\x287', '\x27D', '\x3', '\x2', '\x2', '\x2', '\x287', + '\x27F', '\x3', '\x2', '\x2', '\x2', '\x288', '\'', '\x3', '\x2', '\x2', + '\x2', '\x289', '\x28A', '\a', '\x66', '\x2', '\x2', '\x28A', '\x28B', + '\x5', '\x16', '\f', '\x2', '\x28B', ')', '\x3', '\x2', '\x2', '\x2', + '\x28C', '\x28D', '\a', 'T', '\x2', '\x2', '\x28D', '\x28E', '\x5', ',', + '\x17', '\x2', '\x28E', '\x28F', '\a', 'S', '\x2', '\x2', '\x28F', '+', + '\x3', '\x2', '\x2', '\x2', '\x290', '\x295', '\x5', '.', '\x18', '\x2', + '\x291', '\x292', '\a', 'M', '\x2', '\x2', '\x292', '\x294', '\x5', '.', + '\x18', '\x2', '\x293', '\x291', '\x3', '\x2', '\x2', '\x2', '\x294', + '\x297', '\x3', '\x2', '\x2', '\x2', '\x295', '\x293', '\x3', '\x2', '\x2', + '\x2', '\x295', '\x296', '\x3', '\x2', '\x2', '\x2', '\x296', '-', '\x3', + '\x2', '\x2', '\x2', '\x297', '\x295', '\x3', '\x2', '\x2', '\x2', '\x298', + '\x29B', '\x5', '\f', '\a', '\x2', '\x299', '\x29B', '\x5', '\x30', '\x19', + '\x2', '\x29A', '\x298', '\x3', '\x2', '\x2', '\x2', '\x29A', '\x299', + '\x3', '\x2', '\x2', '\x2', '\x29B', '/', '\x3', '\x2', '\x2', '\x2', + '\x29C', '\x29E', '\x5', '\xF2', 'z', '\x2', '\x29D', '\x29C', '\x3', + '\x2', '\x2', '\x2', '\x29E', '\x2A1', '\x3', '\x2', '\x2', '\x2', '\x29F', + '\x29D', '\x3', '\x2', '\x2', '\x2', '\x29F', '\x2A0', '\x3', '\x2', '\x2', + '\x2', '\x2A0', '\x2A2', '\x3', '\x2', '\x2', '\x2', '\x2A1', '\x29F', + '\x3', '\x2', '\x2', '\x2', '\x2A2', '\x2A4', '\a', 'W', '\x2', '\x2', + '\x2A3', '\x2A5', '\x5', '\x32', '\x1A', '\x2', '\x2A4', '\x2A3', '\x3', + '\x2', '\x2', '\x2', '\x2A4', '\x2A5', '\x3', '\x2', '\x2', '\x2', '\x2A5', + '\x31', '\x3', '\x2', '\x2', '\x2', '\x2A6', '\x2A7', '\a', '\x14', '\x2', + '\x2', '\x2A7', '\x2AB', '\x5', '\f', '\a', '\x2', '\x2A8', '\x2A9', '\a', + '\x30', '\x2', '\x2', '\x2A9', '\x2AB', '\x5', '\f', '\a', '\x2', '\x2AA', + '\x2A6', '\x3', '\x2', '\x2', '\x2', '\x2AA', '\x2A8', '\x3', '\x2', '\x2', + '\x2', '\x2AB', '\x33', '\x3', '\x2', '\x2', '\x2', '\x2AC', '\x2AD', + '\b', '\x1B', '\x1', '\x2', '\x2AD', '\x2AE', '\x5', '\x1EA', '\xF6', + '\x2', '\x2AE', '\x2B4', '\x3', '\x2', '\x2', '\x2', '\x2AF', '\x2B0', + '\f', '\x3', '\x2', '\x2', '\x2B0', '\x2B1', '\a', 'N', '\x2', '\x2', + '\x2B1', '\x2B3', '\x5', '\x1EA', '\xF6', '\x2', '\x2B2', '\x2AF', '\x3', + '\x2', '\x2', '\x2', '\x2B3', '\x2B6', '\x3', '\x2', '\x2', '\x2', '\x2B4', + '\x2B2', '\x3', '\x2', '\x2', '\x2', '\x2B4', '\x2B5', '\x3', '\x2', '\x2', + '\x2', '\x2B5', '\x35', '\x3', '\x2', '\x2', '\x2', '\x2B6', '\x2B4', + '\x3', '\x2', '\x2', '\x2', '\x2B7', '\x2B8', '\b', '\x1C', '\x1', '\x2', + '\x2B8', '\x2B9', '\x5', '\x1EA', '\xF6', '\x2', '\x2B9', '\x2BF', '\x3', + '\x2', '\x2', '\x2', '\x2BA', '\x2BB', '\f', '\x3', '\x2', '\x2', '\x2BB', + '\x2BC', '\a', 'N', '\x2', '\x2', '\x2BC', '\x2BE', '\x5', '\x1EA', '\xF6', + '\x2', '\x2BD', '\x2BA', '\x3', '\x2', '\x2', '\x2', '\x2BE', '\x2C1', + '\x3', '\x2', '\x2', '\x2', '\x2BF', '\x2BD', '\x3', '\x2', '\x2', '\x2', + '\x2BF', '\x2C0', '\x3', '\x2', '\x2', '\x2', '\x2C0', '\x37', '\x3', + '\x2', '\x2', '\x2', '\x2C1', '\x2BF', '\x3', '\x2', '\x2', '\x2', '\x2C2', + '\x2C8', '\x5', '\x1EA', '\xF6', '\x2', '\x2C3', '\x2C4', '\x5', ':', + '\x1E', '\x2', '\x2C4', '\x2C5', '\a', 'N', '\x2', '\x2', '\x2C5', '\x2C6', + '\x5', '\x1EA', '\xF6', '\x2', '\x2C6', '\x2C8', '\x3', '\x2', '\x2', + '\x2', '\x2C7', '\x2C2', '\x3', '\x2', '\x2', '\x2', '\x2C7', '\x2C3', + '\x3', '\x2', '\x2', '\x2', '\x2C8', '\x39', '\x3', '\x2', '\x2', '\x2', + '\x2C9', '\x2CA', '\b', '\x1E', '\x1', '\x2', '\x2CA', '\x2CB', '\x5', + '\x1EA', '\xF6', '\x2', '\x2CB', '\x2D1', '\x3', '\x2', '\x2', '\x2', + '\x2CC', '\x2CD', '\f', '\x3', '\x2', '\x2', '\x2CD', '\x2CE', '\a', 'N', + '\x2', '\x2', '\x2CE', '\x2D0', '\x5', '\x1EA', '\xF6', '\x2', '\x2CF', + '\x2CC', '\x3', '\x2', '\x2', '\x2', '\x2D0', '\x2D3', '\x3', '\x2', '\x2', + '\x2', '\x2D1', '\x2CF', '\x3', '\x2', '\x2', '\x2', '\x2D1', '\x2D2', + '\x3', '\x2', '\x2', '\x2', '\x2D2', ';', '\x3', '\x2', '\x2', '\x2', + '\x2D3', '\x2D1', '\x3', '\x2', '\x2', '\x2', '\x2D4', '\x2DA', '\x5', + '\x1EA', '\xF6', '\x2', '\x2D5', '\x2D6', '\x5', '@', '!', '\x2', '\x2D6', + '\x2D7', '\a', 'N', '\x2', '\x2', '\x2D7', '\x2D8', '\x5', '\x1EA', '\xF6', + '\x2', '\x2D8', '\x2DA', '\x3', '\x2', '\x2', '\x2', '\x2D9', '\x2D4', + '\x3', '\x2', '\x2', '\x2', '\x2D9', '\x2D5', '\x3', '\x2', '\x2', '\x2', + '\x2DA', '=', '\x3', '\x2', '\x2', '\x2', '\x2DB', '\x2DC', '\x5', '\x1EA', + '\xF6', '\x2', '\x2DC', '?', '\x3', '\x2', '\x2', '\x2', '\x2DD', '\x2DE', + '\b', '!', '\x1', '\x2', '\x2DE', '\x2DF', '\x5', '\x1EA', '\xF6', '\x2', + '\x2DF', '\x2E5', '\x3', '\x2', '\x2', '\x2', '\x2E0', '\x2E1', '\f', + '\x3', '\x2', '\x2', '\x2E1', '\x2E2', '\a', 'N', '\x2', '\x2', '\x2E2', + '\x2E4', '\x5', '\x1EA', '\xF6', '\x2', '\x2E3', '\x2E0', '\x3', '\x2', + '\x2', '\x2', '\x2E4', '\x2E7', '\x3', '\x2', '\x2', '\x2', '\x2E5', '\x2E3', + '\x3', '\x2', '\x2', '\x2', '\x2E5', '\x2E6', '\x3', '\x2', '\x2', '\x2', + '\x2E6', '\x41', '\x3', '\x2', '\x2', '\x2', '\x2E7', '\x2E5', '\x3', + '\x2', '\x2', '\x2', '\x2E8', '\x2EB', '\x5', '\x44', '#', '\x2', '\x2E9', + '\x2EB', '\x5', '\x46', '$', '\x2', '\x2EA', '\x2E8', '\x3', '\x2', '\x2', + '\x2', '\x2EA', '\x2E9', '\x3', '\x2', '\x2', '\x2', '\x2EB', '\x43', + '\x3', '\x2', '\x2', '\x2', '\x2EC', '\x2EE', '\x5', 'H', '%', '\x2', + '\x2ED', '\x2EC', '\x3', '\x2', '\x2', '\x2', '\x2ED', '\x2EE', '\x3', + '\x2', '\x2', '\x2', '\x2EE', '\x2F2', '\x3', '\x2', '\x2', '\x2', '\x2EF', + '\x2F1', '\x5', 'L', '\'', '\x2', '\x2F0', '\x2EF', '\x3', '\x2', '\x2', + '\x2', '\x2F1', '\x2F4', '\x3', '\x2', '\x2', '\x2', '\x2F2', '\x2F0', + '\x3', '\x2', '\x2', '\x2', '\x2F2', '\x2F3', '\x3', '\x2', '\x2', '\x2', + '\x2F3', '\x2F8', '\x3', '\x2', '\x2', '\x2', '\x2F4', '\x2F2', '\x3', + '\x2', '\x2', '\x2', '\x2F5', '\x2F7', '\x5', 'V', ',', '\x2', '\x2F6', + '\x2F5', '\x3', '\x2', '\x2', '\x2', '\x2F7', '\x2FA', '\x3', '\x2', '\x2', + '\x2', '\x2F8', '\x2F6', '\x3', '\x2', '\x2', '\x2', '\x2F8', '\x2F9', + '\x3', '\x2', '\x2', '\x2', '\x2F9', '\x2FB', '\x3', '\x2', '\x2', '\x2', + '\x2FA', '\x2F8', '\x3', '\x2', '\x2', '\x2', '\x2FB', '\x2FC', '\a', + '\x2', '\x2', '\x3', '\x2FC', '\x45', '\x3', '\x2', '\x2', '\x2', '\x2FD', + '\x2FF', '\x5', 'L', '\'', '\x2', '\x2FE', '\x2FD', '\x3', '\x2', '\x2', + '\x2', '\x2FF', '\x302', '\x3', '\x2', '\x2', '\x2', '\x300', '\x2FE', + '\x3', '\x2', '\x2', '\x2', '\x300', '\x301', '\x3', '\x2', '\x2', '\x2', + '\x301', '\x303', '\x3', '\x2', '\x2', '\x2', '\x302', '\x300', '\x3', + '\x2', '\x2', '\x2', '\x303', '\x304', '\x5', 'X', '-', '\x2', '\x304', + 'G', '\x3', '\x2', '\x2', '\x2', '\x305', '\x307', '\x5', 'J', '&', '\x2', + '\x306', '\x305', '\x3', '\x2', '\x2', '\x2', '\x307', '\x30A', '\x3', + '\x2', '\x2', '\x2', '\x308', '\x306', '\x3', '\x2', '\x2', '\x2', '\x308', + '\x309', '\x3', '\x2', '\x2', '\x2', '\x309', '\x30B', '\x3', '\x2', '\x2', + '\x2', '\x30A', '\x308', '\x3', '\x2', '\x2', '\x2', '\x30B', '\x30C', + '\a', '&', '\x2', '\x2', '\x30C', '\x30D', '\x5', '\x36', '\x1C', '\x2', + '\x30D', '\x30E', '\a', 'L', '\x2', '\x2', '\x30E', 'I', '\x3', '\x2', + '\x2', '\x2', '\x30F', '\x310', '\x5', '\xF2', 'z', '\x2', '\x310', 'K', + '\x3', '\x2', '\x2', '\x2', '\x311', '\x316', '\x5', 'N', '(', '\x2', + '\x312', '\x316', '\x5', 'P', ')', '\x2', '\x313', '\x316', '\x5', 'R', + '*', '\x2', '\x314', '\x316', '\x5', 'T', '+', '\x2', '\x315', '\x311', + '\x3', '\x2', '\x2', '\x2', '\x315', '\x312', '\x3', '\x2', '\x2', '\x2', + '\x315', '\x313', '\x3', '\x2', '\x2', '\x2', '\x315', '\x314', '\x3', + '\x2', '\x2', '\x2', '\x316', 'M', '\x3', '\x2', '\x2', '\x2', '\x317', + '\x318', '\a', '\x1C', '\x2', '\x2', '\x318', '\x319', '\x5', '\x38', + '\x1D', '\x2', '\x319', '\x31A', '\a', 'L', '\x2', '\x2', '\x31A', 'O', + '\x3', '\x2', '\x2', '\x2', '\x31B', '\x31C', '\a', '\x1C', '\x2', '\x2', + '\x31C', '\x31D', '\x5', ':', '\x1E', '\x2', '\x31D', '\x31E', '\a', 'N', + '\x2', '\x2', '\x31E', '\x31F', '\a', '\x64', '\x2', '\x2', '\x31F', '\x320', + '\a', 'L', '\x2', '\x2', '\x320', 'Q', '\x3', '\x2', '\x2', '\x2', '\x321', + '\x322', '\a', '\x1C', '\x2', '\x2', '\x322', '\x323', '\a', '.', '\x2', + '\x2', '\x323', '\x324', '\x5', '\x38', '\x1D', '\x2', '\x324', '\x325', + '\a', 'N', '\x2', '\x2', '\x325', '\x326', '\x5', '\x1EA', '\xF6', '\x2', + '\x326', '\x327', '\a', 'L', '\x2', '\x2', '\x327', 'S', '\x3', '\x2', + '\x2', '\x2', '\x328', '\x329', '\a', '\x1C', '\x2', '\x2', '\x329', '\x32A', + '\a', '.', '\x2', '\x2', '\x32A', '\x32B', '\x5', '\x38', '\x1D', '\x2', + '\x32B', '\x32C', '\a', 'N', '\x2', '\x2', '\x32C', '\x32D', '\a', '\x64', + '\x2', '\x2', '\x32D', '\x32E', '\a', 'L', '\x2', '\x2', '\x32E', 'U', + '\x3', '\x2', '\x2', '\x2', '\x32F', '\x333', '\x5', '^', '\x30', '\x2', + '\x330', '\x333', '\x5', '\xD2', 'j', '\x2', '\x331', '\x333', '\a', 'L', + '\x2', '\x2', '\x332', '\x32F', '\x3', '\x2', '\x2', '\x2', '\x332', '\x330', + '\x3', '\x2', '\x2', '\x2', '\x332', '\x331', '\x3', '\x2', '\x2', '\x2', + '\x333', 'W', '\x3', '\x2', '\x2', '\x2', '\x334', '\x336', '\x5', '\xF2', + 'z', '\x2', '\x335', '\x334', '\x3', '\x2', '\x2', '\x2', '\x336', '\x339', + '\x3', '\x2', '\x2', '\x2', '\x337', '\x335', '\x3', '\x2', '\x2', '\x2', + '\x337', '\x338', '\x3', '\x2', '\x2', '\x2', '\x338', '\x33B', '\x3', + '\x2', '\x2', '\x2', '\x339', '\x337', '\x3', '\x2', '\x2', '\x2', '\x33A', + '\x33C', '\a', '$', '\x2', '\x2', '\x33B', '\x33A', '\x3', '\x2', '\x2', + '\x2', '\x33B', '\x33C', '\x3', '\x2', '\x2', '\x2', '\x33C', '\x33D', + '\x3', '\x2', '\x2', '\x2', '\x33D', '\x33E', '\a', '!', '\x2', '\x2', + '\x33E', '\x33F', '\x5', '\x34', '\x1B', '\x2', '\x33F', '\x343', '\a', + 'H', '\x2', '\x2', '\x340', '\x342', '\x5', 'Z', '.', '\x2', '\x341', + '\x340', '\x3', '\x2', '\x2', '\x2', '\x342', '\x345', '\x3', '\x2', '\x2', + '\x2', '\x343', '\x341', '\x3', '\x2', '\x2', '\x2', '\x343', '\x344', + '\x3', '\x2', '\x2', '\x2', '\x344', '\x346', '\x3', '\x2', '\x2', '\x2', + '\x345', '\x343', '\x3', '\x2', '\x2', '\x2', '\x346', '\x347', '\a', + 'I', '\x2', '\x2', '\x347', 'Y', '\x3', '\x2', '\x2', '\x2', '\x348', + '\x34C', '\a', '+', '\x2', '\x2', '\x349', '\x34B', '\x5', '\\', '/', + '\x2', '\x34A', '\x349', '\x3', '\x2', '\x2', '\x2', '\x34B', '\x34E', + '\x3', '\x2', '\x2', '\x2', '\x34C', '\x34A', '\x3', '\x2', '\x2', '\x2', + '\x34C', '\x34D', '\x3', '\x2', '\x2', '\x2', '\x34D', '\x34F', '\x3', + '\x2', '\x2', '\x2', '\x34E', '\x34C', '\x3', '\x2', '\x2', '\x2', '\x34F', + '\x350', '\x5', '\x34', '\x1B', '\x2', '\x350', '\x351', '\a', 'L', '\x2', + '\x2', '\x351', '\x382', '\x3', '\x2', '\x2', '\x2', '\x352', '\x353', + '\a', '\x13', '\x2', '\x2', '\x353', '\x35D', '\x5', '\x36', '\x1C', '\x2', + '\x354', '\x355', '\a', '\x36', '\x2', '\x2', '\x355', '\x35A', '\x5', + '\x34', '\x1B', '\x2', '\x356', '\x357', '\a', 'M', '\x2', '\x2', '\x357', + '\x359', '\x5', '\x34', '\x1B', '\x2', '\x358', '\x356', '\x3', '\x2', + '\x2', '\x2', '\x359', '\x35C', '\x3', '\x2', '\x2', '\x2', '\x35A', '\x358', + '\x3', '\x2', '\x2', '\x2', '\x35A', '\x35B', '\x3', '\x2', '\x2', '\x2', + '\x35B', '\x35E', '\x3', '\x2', '\x2', '\x2', '\x35C', '\x35A', '\x3', + '\x2', '\x2', '\x2', '\x35D', '\x354', '\x3', '\x2', '\x2', '\x2', '\x35D', + '\x35E', '\x3', '\x2', '\x2', '\x2', '\x35E', '\x35F', '\x3', '\x2', '\x2', + '\x2', '\x35F', '\x360', '\a', 'L', '\x2', '\x2', '\x360', '\x382', '\x3', + '\x2', '\x2', '\x2', '\x361', '\x362', '\a', '%', '\x2', '\x2', '\x362', + '\x36C', '\x5', '\x36', '\x1C', '\x2', '\x363', '\x364', '\a', '\x36', + '\x2', '\x2', '\x364', '\x369', '\x5', '\x34', '\x1B', '\x2', '\x365', + '\x366', '\a', 'M', '\x2', '\x2', '\x366', '\x368', '\x5', '\x34', '\x1B', + '\x2', '\x367', '\x365', '\x3', '\x2', '\x2', '\x2', '\x368', '\x36B', + '\x3', '\x2', '\x2', '\x2', '\x369', '\x367', '\x3', '\x2', '\x2', '\x2', + '\x369', '\x36A', '\x3', '\x2', '\x2', '\x2', '\x36A', '\x36D', '\x3', + '\x2', '\x2', '\x2', '\x36B', '\x369', '\x3', '\x2', '\x2', '\x2', '\x36C', + '\x363', '\x3', '\x2', '\x2', '\x2', '\x36C', '\x36D', '\x3', '\x2', '\x2', + '\x2', '\x36D', '\x36E', '\x3', '\x2', '\x2', '\x2', '\x36E', '\x36F', + '\a', 'L', '\x2', '\x2', '\x36F', '\x382', '\x3', '\x2', '\x2', '\x2', + '\x370', '\x371', '\a', ':', '\x2', '\x2', '\x371', '\x372', '\x5', '\x38', + '\x1D', '\x2', '\x372', '\x373', '\a', 'L', '\x2', '\x2', '\x373', '\x382', + '\x3', '\x2', '\x2', '\x2', '\x374', '\x375', '\a', ')', '\x2', '\x2', + '\x375', '\x376', '\x5', '\x38', '\x1D', '\x2', '\x376', '\x377', '\a', + '>', '\x2', '\x2', '\x377', '\x37C', '\x5', '\x38', '\x1D', '\x2', '\x378', + '\x379', '\a', 'M', '\x2', '\x2', '\x379', '\x37B', '\x5', '\x38', '\x1D', + '\x2', '\x37A', '\x378', '\x3', '\x2', '\x2', '\x2', '\x37B', '\x37E', + '\x3', '\x2', '\x2', '\x2', '\x37C', '\x37A', '\x3', '\x2', '\x2', '\x2', + '\x37C', '\x37D', '\x3', '\x2', '\x2', '\x2', '\x37D', '\x37F', '\x3', + '\x2', '\x2', '\x2', '\x37E', '\x37C', '\x3', '\x2', '\x2', '\x2', '\x37F', + '\x380', '\a', 'L', '\x2', '\x2', '\x380', '\x382', '\x3', '\x2', '\x2', + '\x2', '\x381', '\x348', '\x3', '\x2', '\x2', '\x2', '\x381', '\x352', + '\x3', '\x2', '\x2', '\x2', '\x381', '\x361', '\x3', '\x2', '\x2', '\x2', + '\x381', '\x370', '\x3', '\x2', '\x2', '\x2', '\x381', '\x374', '\x3', + '\x2', '\x2', '\x2', '\x382', '[', '\x3', '\x2', '\x2', '\x2', '\x383', + '\x384', '\t', '\x5', '\x2', '\x2', '\x384', ']', '\x3', '\x2', '\x2', + '\x2', '\x385', '\x388', '\x5', '`', '\x31', '\x2', '\x386', '\x388', + '\x5', '\xC6', '\x64', '\x2', '\x387', '\x385', '\x3', '\x2', '\x2', '\x2', + '\x387', '\x386', '\x3', '\x2', '\x2', '\x2', '\x388', '_', '\x3', '\x2', + '\x2', '\x2', '\x389', '\x38B', '\x5', '\x62', '\x32', '\x2', '\x38A', + '\x389', '\x3', '\x2', '\x2', '\x2', '\x38B', '\x38E', '\x3', '\x2', '\x2', + '\x2', '\x38C', '\x38A', '\x3', '\x2', '\x2', '\x2', '\x38C', '\x38D', + '\x3', '\x2', '\x2', '\x2', '\x38D', '\x38F', '\x3', '\x2', '\x2', '\x2', + '\x38E', '\x38C', '\x3', '\x2', '\x2', '\x2', '\x38F', '\x390', '\a', + '\v', '\x2', '\x2', '\x390', '\x392', '\x5', '\x1EA', '\xF6', '\x2', '\x391', + '\x393', '\x5', '\x64', '\x33', '\x2', '\x392', '\x391', '\x3', '\x2', + '\x2', '\x2', '\x392', '\x393', '\x3', '\x2', '\x2', '\x2', '\x393', '\x395', + '\x3', '\x2', '\x2', '\x2', '\x394', '\x396', '\x5', 'h', '\x35', '\x2', + '\x395', '\x394', '\x3', '\x2', '\x2', '\x2', '\x395', '\x396', '\x3', + '\x2', '\x2', '\x2', '\x396', '\x398', '\x3', '\x2', '\x2', '\x2', '\x397', + '\x399', '\x5', 'j', '\x36', '\x2', '\x398', '\x397', '\x3', '\x2', '\x2', + '\x2', '\x398', '\x399', '\x3', '\x2', '\x2', '\x2', '\x399', '\x39A', + '\x3', '\x2', '\x2', '\x2', '\x39A', '\x39B', '\x5', 'n', '\x38', '\x2', + '\x39B', '\x61', '\x3', '\x2', '\x2', '\x2', '\x39C', '\x3A5', '\x5', + '\xF2', 'z', '\x2', '\x39D', '\x3A5', '\a', '*', '\x2', '\x2', '\x39E', + '\x3A5', '\a', '(', '\x2', '\x2', '\x39F', '\x3A5', '\a', '\'', '\x2', + '\x2', '\x3A0', '\x3A5', '\a', '\x3', '\x2', '\x2', '\x3A1', '\x3A5', + '\a', '.', '\x2', '\x2', '\x3A2', '\x3A5', '\a', '\x15', '\x2', '\x2', + '\x3A3', '\x3A5', '\a', '/', '\x2', '\x2', '\x3A4', '\x39C', '\x3', '\x2', + '\x2', '\x2', '\x3A4', '\x39D', '\x3', '\x2', '\x2', '\x2', '\x3A4', '\x39E', + '\x3', '\x2', '\x2', '\x2', '\x3A4', '\x39F', '\x3', '\x2', '\x2', '\x2', + '\x3A4', '\x3A0', '\x3', '\x2', '\x2', '\x2', '\x3A4', '\x3A1', '\x3', + '\x2', '\x2', '\x2', '\x3A4', '\x3A2', '\x3', '\x2', '\x2', '\x2', '\x3A4', + '\x3A3', '\x3', '\x2', '\x2', '\x2', '\x3A5', '\x63', '\x3', '\x2', '\x2', + '\x2', '\x3A6', '\x3A7', '\a', 'T', '\x2', '\x2', '\x3A7', '\x3A8', '\x5', + '\x66', '\x34', '\x2', '\x3A8', '\x3A9', '\a', 'S', '\x2', '\x2', '\x3A9', + '\x65', '\x3', '\x2', '\x2', '\x2', '\x3AA', '\x3AF', '\x5', '\"', '\x12', + '\x2', '\x3AB', '\x3AC', '\a', 'M', '\x2', '\x2', '\x3AC', '\x3AE', '\x5', + '\"', '\x12', '\x2', '\x3AD', '\x3AB', '\x3', '\x2', '\x2', '\x2', '\x3AE', + '\x3B1', '\x3', '\x2', '\x2', '\x2', '\x3AF', '\x3AD', '\x3', '\x2', '\x2', + '\x2', '\x3AF', '\x3B0', '\x3', '\x2', '\x2', '\x2', '\x3B0', 'g', '\x3', + '\x2', '\x2', '\x2', '\x3B1', '\x3AF', '\x3', '\x2', '\x2', '\x2', '\x3B2', + '\x3B3', '\a', '\x14', '\x2', '\x2', '\x3B3', '\x3B4', '\x5', '\x10', + '\t', '\x2', '\x3B4', 'i', '\x3', '\x2', '\x2', '\x2', '\x3B5', '\x3B6', + '\a', '\x1B', '\x2', '\x2', '\x3B6', '\x3B7', '\x5', 'l', '\x37', '\x2', + '\x3B7', 'k', '\x3', '\x2', '\x2', '\x2', '\x3B8', '\x3BD', '\x5', '\x16', + '\f', '\x2', '\x3B9', '\x3BA', '\a', 'M', '\x2', '\x2', '\x3BA', '\x3BC', + '\x5', '\x16', '\f', '\x2', '\x3BB', '\x3B9', '\x3', '\x2', '\x2', '\x2', + '\x3BC', '\x3BF', '\x3', '\x2', '\x2', '\x2', '\x3BD', '\x3BB', '\x3', + '\x2', '\x2', '\x2', '\x3BD', '\x3BE', '\x3', '\x2', '\x2', '\x2', '\x3BE', + 'm', '\x3', '\x2', '\x2', '\x2', '\x3BF', '\x3BD', '\x3', '\x2', '\x2', + '\x2', '\x3C0', '\x3C4', '\a', 'H', '\x2', '\x2', '\x3C1', '\x3C3', '\x5', + 'p', '\x39', '\x2', '\x3C2', '\x3C1', '\x3', '\x2', '\x2', '\x2', '\x3C3', + '\x3C6', '\x3', '\x2', '\x2', '\x2', '\x3C4', '\x3C2', '\x3', '\x2', '\x2', + '\x2', '\x3C4', '\x3C5', '\x3', '\x2', '\x2', '\x2', '\x3C5', '\x3C7', + '\x3', '\x2', '\x2', '\x2', '\x3C6', '\x3C4', '\x3', '\x2', '\x2', '\x2', + '\x3C7', '\x3C8', '\a', 'I', '\x2', '\x2', '\x3C8', 'o', '\x3', '\x2', + '\x2', '\x2', '\x3C9', '\x3CE', '\x5', 'r', ':', '\x2', '\x3CA', '\x3CE', + '\x5', '\xB6', '\\', '\x2', '\x3CB', '\x3CE', '\x5', '\xB8', ']', '\x2', + '\x3CC', '\x3CE', '\x5', '\xBA', '^', '\x2', '\x3CD', '\x3C9', '\x3', + '\x2', '\x2', '\x2', '\x3CD', '\x3CA', '\x3', '\x2', '\x2', '\x2', '\x3CD', + '\x3CB', '\x3', '\x2', '\x2', '\x2', '\x3CD', '\x3CC', '\x3', '\x2', '\x2', + '\x2', '\x3CE', 'q', '\x3', '\x2', '\x2', '\x2', '\x3CF', '\x3D5', '\x5', + 't', ';', '\x2', '\x3D0', '\x3D5', '\x5', '\x98', 'M', '\x2', '\x3D1', + '\x3D5', '\x5', '^', '\x30', '\x2', '\x3D2', '\x3D5', '\x5', '\xD2', 'j', + '\x2', '\x3D3', '\x3D5', '\a', 'L', '\x2', '\x2', '\x3D4', '\x3CF', '\x3', + '\x2', '\x2', '\x2', '\x3D4', '\x3D0', '\x3', '\x2', '\x2', '\x2', '\x3D4', + '\x3D1', '\x3', '\x2', '\x2', '\x2', '\x3D4', '\x3D2', '\x3', '\x2', '\x2', + '\x2', '\x3D4', '\x3D3', '\x3', '\x2', '\x2', '\x2', '\x3D5', 's', '\x3', + '\x2', '\x2', '\x2', '\x3D6', '\x3D8', '\x5', 'v', '<', '\x2', '\x3D7', + '\x3D6', '\x3', '\x2', '\x2', '\x2', '\x3D8', '\x3DB', '\x3', '\x2', '\x2', + '\x2', '\x3D9', '\x3D7', '\x3', '\x2', '\x2', '\x2', '\x3D9', '\x3DA', + '\x3', '\x2', '\x2', '\x2', '\x3DA', '\x3DC', '\x3', '\x2', '\x2', '\x2', + '\x3DB', '\x3D9', '\x3', '\x2', '\x2', '\x2', '\x3DC', '\x3DD', '\x5', + '\x80', '\x41', '\x2', '\x3DD', '\x3DE', '\x5', 'x', '=', '\x2', '\x3DE', + '\x3DF', '\a', 'L', '\x2', '\x2', '\x3DF', 'u', '\x3', '\x2', '\x2', '\x2', + '\x3E0', '\x3E9', '\x5', '\xF2', 'z', '\x2', '\x3E1', '\x3E9', '\a', '*', + '\x2', '\x2', '\x3E2', '\x3E9', '\a', '(', '\x2', '\x2', '\x3E3', '\x3E9', + '\a', '\'', '\x2', '\x2', '\x3E4', '\x3E9', '\a', '.', '\x2', '\x2', '\x3E5', + '\x3E9', '\a', '\x15', '\x2', '\x2', '\x3E6', '\x3E9', '\a', '\x37', '\x2', + '\x2', '\x3E7', '\x3E9', '\a', '<', '\x2', '\x2', '\x3E8', '\x3E0', '\x3', + '\x2', '\x2', '\x2', '\x3E8', '\x3E1', '\x3', '\x2', '\x2', '\x2', '\x3E8', + '\x3E2', '\x3', '\x2', '\x2', '\x2', '\x3E8', '\x3E3', '\x3', '\x2', '\x2', + '\x2', '\x3E8', '\x3E4', '\x3', '\x2', '\x2', '\x2', '\x3E8', '\x3E5', + '\x3', '\x2', '\x2', '\x2', '\x3E8', '\x3E6', '\x3', '\x2', '\x2', '\x2', + '\x3E8', '\x3E7', '\x3', '\x2', '\x2', '\x2', '\x3E9', 'w', '\x3', '\x2', + '\x2', '\x2', '\x3EA', '\x3EF', '\x5', 'z', '>', '\x2', '\x3EB', '\x3EC', + '\a', 'M', '\x2', '\x2', '\x3EC', '\x3EE', '\x5', 'z', '>', '\x2', '\x3ED', + '\x3EB', '\x3', '\x2', '\x2', '\x2', '\x3EE', '\x3F1', '\x3', '\x2', '\x2', + '\x2', '\x3EF', '\x3ED', '\x3', '\x2', '\x2', '\x2', '\x3EF', '\x3F0', + '\x3', '\x2', '\x2', '\x2', '\x3F0', 'y', '\x3', '\x2', '\x2', '\x2', + '\x3F1', '\x3EF', '\x3', '\x2', '\x2', '\x2', '\x3F2', '\x3F5', '\x5', + '|', '?', '\x2', '\x3F3', '\x3F4', '\a', 'R', '\x2', '\x2', '\x3F4', '\x3F6', + '\x5', '~', '@', '\x2', '\x3F5', '\x3F3', '\x3', '\x2', '\x2', '\x2', + '\x3F5', '\x3F6', '\x3', '\x2', '\x2', '\x2', '\x3F6', '{', '\x3', '\x2', + '\x2', '\x2', '\x3F7', '\x3F9', '\x5', '\x1EA', '\xF6', '\x2', '\x3F8', + '\x3FA', '\x5', ' ', '\x11', '\x2', '\x3F9', '\x3F8', '\x3', '\x2', '\x2', + '\x2', '\x3F9', '\x3FA', '\x3', '\x2', '\x2', '\x2', '\x3FA', '}', '\x3', + '\x2', '\x2', '\x2', '\x3FB', '\x3FE', '\x5', '\x1AE', '\xD8', '\x2', + '\x3FC', '\x3FE', '\x5', '\x104', '\x83', '\x2', '\x3FD', '\x3FB', '\x3', + '\x2', '\x2', '\x2', '\x3FD', '\x3FC', '\x3', '\x2', '\x2', '\x2', '\x3FE', + '\x7F', '\x3', '\x2', '\x2', '\x2', '\x3FF', '\x402', '\x5', '\x82', '\x42', + '\x2', '\x400', '\x402', '\x5', '\x84', '\x43', '\x2', '\x401', '\x3FF', + '\x3', '\x2', '\x2', '\x2', '\x401', '\x400', '\x3', '\x2', '\x2', '\x2', + '\x402', '\x81', '\x3', '\x2', '\x2', '\x2', '\x403', '\x406', '\x5', + '\x6', '\x4', '\x2', '\x404', '\x406', '\a', '\x5', '\x2', '\x2', '\x405', + '\x403', '\x3', '\x2', '\x2', '\x2', '\x405', '\x404', '\x3', '\x2', '\x2', + '\x2', '\x406', '\x83', '\x3', '\x2', '\x2', '\x2', '\x407', '\x40B', + '\x5', '\x86', '\x44', '\x2', '\x408', '\x40B', '\x5', '\x94', 'K', '\x2', + '\x409', '\x40B', '\x5', '\x96', 'L', '\x2', '\x40A', '\x407', '\x3', + '\x2', '\x2', '\x2', '\x40A', '\x408', '\x3', '\x2', '\x2', '\x2', '\x40A', + '\x409', '\x3', '\x2', '\x2', '\x2', '\x40B', '\x85', '\x3', '\x2', '\x2', + '\x2', '\x40C', '\x40F', '\x5', '\x8C', 'G', '\x2', '\x40D', '\x40F', + '\x5', '\x92', 'J', '\x2', '\x40E', '\x40C', '\x3', '\x2', '\x2', '\x2', + '\x40E', '\x40D', '\x3', '\x2', '\x2', '\x2', '\x40F', '\x414', '\x3', + '\x2', '\x2', '\x2', '\x410', '\x413', '\x5', '\x8A', '\x46', '\x2', '\x411', + '\x413', '\x5', '\x90', 'I', '\x2', '\x412', '\x410', '\x3', '\x2', '\x2', + '\x2', '\x412', '\x411', '\x3', '\x2', '\x2', '\x2', '\x413', '\x416', + '\x3', '\x2', '\x2', '\x2', '\x414', '\x412', '\x3', '\x2', '\x2', '\x2', + '\x414', '\x415', '\x3', '\x2', '\x2', '\x2', '\x415', '\x87', '\x3', + '\x2', '\x2', '\x2', '\x416', '\x414', '\x3', '\x2', '\x2', '\x2', '\x417', + '\x419', '\x5', '\x1EA', '\xF6', '\x2', '\x418', '\x41A', '\x5', '*', + '\x16', '\x2', '\x419', '\x418', '\x3', '\x2', '\x2', '\x2', '\x419', + '\x41A', '\x3', '\x2', '\x2', '\x2', '\x41A', '\x428', '\x3', '\x2', '\x2', + '\x2', '\x41B', '\x41C', '\x5', '\x86', '\x44', '\x2', '\x41C', '\x420', + '\a', 'N', '\x2', '\x2', '\x41D', '\x41F', '\x5', '\xF2', 'z', '\x2', + '\x41E', '\x41D', '\x3', '\x2', '\x2', '\x2', '\x41F', '\x422', '\x3', + '\x2', '\x2', '\x2', '\x420', '\x41E', '\x3', '\x2', '\x2', '\x2', '\x420', + '\x421', '\x3', '\x2', '\x2', '\x2', '\x421', '\x423', '\x3', '\x2', '\x2', + '\x2', '\x422', '\x420', '\x3', '\x2', '\x2', '\x2', '\x423', '\x425', + '\x5', '\x1EA', '\xF6', '\x2', '\x424', '\x426', '\x5', '*', '\x16', '\x2', + '\x425', '\x424', '\x3', '\x2', '\x2', '\x2', '\x425', '\x426', '\x3', + '\x2', '\x2', '\x2', '\x426', '\x428', '\x3', '\x2', '\x2', '\x2', '\x427', + '\x417', '\x3', '\x2', '\x2', '\x2', '\x427', '\x41B', '\x3', '\x2', '\x2', + '\x2', '\x428', '\x89', '\x3', '\x2', '\x2', '\x2', '\x429', '\x42D', + '\a', 'N', '\x2', '\x2', '\x42A', '\x42C', '\x5', '\xF2', 'z', '\x2', + '\x42B', '\x42A', '\x3', '\x2', '\x2', '\x2', '\x42C', '\x42F', '\x3', + '\x2', '\x2', '\x2', '\x42D', '\x42B', '\x3', '\x2', '\x2', '\x2', '\x42D', + '\x42E', '\x3', '\x2', '\x2', '\x2', '\x42E', '\x430', '\x3', '\x2', '\x2', + '\x2', '\x42F', '\x42D', '\x3', '\x2', '\x2', '\x2', '\x430', '\x432', + '\x5', '\x1EA', '\xF6', '\x2', '\x431', '\x433', '\x5', '*', '\x16', '\x2', + '\x432', '\x431', '\x3', '\x2', '\x2', '\x2', '\x432', '\x433', '\x3', + '\x2', '\x2', '\x2', '\x433', '\x8B', '\x3', '\x2', '\x2', '\x2', '\x434', + '\x436', '\x5', '\x1EA', '\xF6', '\x2', '\x435', '\x437', '\x5', '*', + '\x16', '\x2', '\x436', '\x435', '\x3', '\x2', '\x2', '\x2', '\x436', + '\x437', '\x3', '\x2', '\x2', '\x2', '\x437', '\x8D', '\x3', '\x2', '\x2', + '\x2', '\x438', '\x439', '\x5', '\x88', '\x45', '\x2', '\x439', '\x8F', + '\x3', '\x2', '\x2', '\x2', '\x43A', '\x43B', '\x5', '\x8A', '\x46', '\x2', + '\x43B', '\x91', '\x3', '\x2', '\x2', '\x2', '\x43C', '\x43D', '\x5', + '\x8C', 'G', '\x2', '\x43D', '\x93', '\x3', '\x2', '\x2', '\x2', '\x43E', + '\x43F', '\x5', '\x1EA', '\xF6', '\x2', '\x43F', '\x95', '\x3', '\x2', + '\x2', '\x2', '\x440', '\x441', '\x5', '\x82', '\x42', '\x2', '\x441', + '\x442', '\x5', ' ', '\x11', '\x2', '\x442', '\x44A', '\x3', '\x2', '\x2', + '\x2', '\x443', '\x444', '\x5', '\x86', '\x44', '\x2', '\x444', '\x445', + '\x5', ' ', '\x11', '\x2', '\x445', '\x44A', '\x3', '\x2', '\x2', '\x2', + '\x446', '\x447', '\x5', '\x94', 'K', '\x2', '\x447', '\x448', '\x5', + ' ', '\x11', '\x2', '\x448', '\x44A', '\x3', '\x2', '\x2', '\x2', '\x449', + '\x440', '\x3', '\x2', '\x2', '\x2', '\x449', '\x443', '\x3', '\x2', '\x2', + '\x2', '\x449', '\x446', '\x3', '\x2', '\x2', '\x2', '\x44A', '\x97', + '\x3', '\x2', '\x2', '\x2', '\x44B', '\x44D', '\x5', '\x9A', 'N', '\x2', + '\x44C', '\x44B', '\x3', '\x2', '\x2', '\x2', '\x44D', '\x450', '\x3', + '\x2', '\x2', '\x2', '\x44E', '\x44C', '\x3', '\x2', '\x2', '\x2', '\x44E', + '\x44F', '\x3', '\x2', '\x2', '\x2', '\x44F', '\x451', '\x3', '\x2', '\x2', + '\x2', '\x450', '\x44E', '\x3', '\x2', '\x2', '\x2', '\x451', '\x452', + '\x5', '\x9C', 'O', '\x2', '\x452', '\x453', '\x5', '\xB4', '[', '\x2', + '\x453', '\x99', '\x3', '\x2', '\x2', '\x2', '\x454', '\x45F', '\x5', + '\xF2', 'z', '\x2', '\x455', '\x45F', '\a', '*', '\x2', '\x2', '\x456', + '\x45F', '\a', '(', '\x2', '\x2', '\x457', '\x45F', '\a', '\'', '\x2', + '\x2', '\x458', '\x45F', '\a', '\x3', '\x2', '\x2', '\x459', '\x45F', + '\a', '.', '\x2', '\x2', '\x45A', '\x45F', '\a', '\x15', '\x2', '\x2', + '\x45B', '\x45F', '\a', '\x32', '\x2', '\x2', '\x45C', '\x45F', '\a', + '\"', '\x2', '\x2', '\x45D', '\x45F', '\a', '/', '\x2', '\x2', '\x45E', + '\x454', '\x3', '\x2', '\x2', '\x2', '\x45E', '\x455', '\x3', '\x2', '\x2', + '\x2', '\x45E', '\x456', '\x3', '\x2', '\x2', '\x2', '\x45E', '\x457', + '\x3', '\x2', '\x2', '\x2', '\x45E', '\x458', '\x3', '\x2', '\x2', '\x2', + '\x45E', '\x459', '\x3', '\x2', '\x2', '\x2', '\x45E', '\x45A', '\x3', + '\x2', '\x2', '\x2', '\x45E', '\x45B', '\x3', '\x2', '\x2', '\x2', '\x45E', + '\x45C', '\x3', '\x2', '\x2', '\x2', '\x45E', '\x45D', '\x3', '\x2', '\x2', + '\x2', '\x45F', '\x9B', '\x3', '\x2', '\x2', '\x2', '\x460', '\x461', + '\x5', '\x9E', 'P', '\x2', '\x461', '\x463', '\x5', '\xA0', 'Q', '\x2', + '\x462', '\x464', '\x5', '\xAE', 'X', '\x2', '\x463', '\x462', '\x3', + '\x2', '\x2', '\x2', '\x463', '\x464', '\x3', '\x2', '\x2', '\x2', '\x464', + '\x472', '\x3', '\x2', '\x2', '\x2', '\x465', '\x469', '\x5', '\x64', + '\x33', '\x2', '\x466', '\x468', '\x5', '\xF2', 'z', '\x2', '\x467', '\x466', + '\x3', '\x2', '\x2', '\x2', '\x468', '\x46B', '\x3', '\x2', '\x2', '\x2', + '\x469', '\x467', '\x3', '\x2', '\x2', '\x2', '\x469', '\x46A', '\x3', + '\x2', '\x2', '\x2', '\x46A', '\x46C', '\x3', '\x2', '\x2', '\x2', '\x46B', + '\x469', '\x3', '\x2', '\x2', '\x2', '\x46C', '\x46D', '\x5', '\x9E', + 'P', '\x2', '\x46D', '\x46F', '\x5', '\xA0', 'Q', '\x2', '\x46E', '\x470', + '\x5', '\xAE', 'X', '\x2', '\x46F', '\x46E', '\x3', '\x2', '\x2', '\x2', + '\x46F', '\x470', '\x3', '\x2', '\x2', '\x2', '\x470', '\x472', '\x3', + '\x2', '\x2', '\x2', '\x471', '\x460', '\x3', '\x2', '\x2', '\x2', '\x471', + '\x465', '\x3', '\x2', '\x2', '\x2', '\x472', '\x9D', '\x3', '\x2', '\x2', + '\x2', '\x473', '\x476', '\x5', '\x80', '\x41', '\x2', '\x474', '\x476', + '\a', ';', '\x2', '\x2', '\x475', '\x473', '\x3', '\x2', '\x2', '\x2', + '\x475', '\x474', '\x3', '\x2', '\x2', '\x2', '\x476', '\x9F', '\x3', + '\x2', '\x2', '\x2', '\x477', '\x478', '\x5', '\x1EA', '\xF6', '\x2', + '\x478', '\x47A', '\a', '\x46', '\x2', '\x2', '\x479', '\x47B', '\x5', + '\xA2', 'R', '\x2', '\x47A', '\x479', '\x3', '\x2', '\x2', '\x2', '\x47A', + '\x47B', '\x3', '\x2', '\x2', '\x2', '\x47B', '\x47C', '\x3', '\x2', '\x2', + '\x2', '\x47C', '\x47E', '\a', 'G', '\x2', '\x2', '\x47D', '\x47F', '\x5', + ' ', '\x11', '\x2', '\x47E', '\x47D', '\x3', '\x2', '\x2', '\x2', '\x47E', + '\x47F', '\x3', '\x2', '\x2', '\x2', '\x47F', '\xA1', '\x3', '\x2', '\x2', + '\x2', '\x480', '\x481', '\x5', '\xA4', 'S', '\x2', '\x481', '\x482', + '\a', 'M', '\x2', '\x2', '\x482', '\x483', '\x5', '\xAA', 'V', '\x2', + '\x483', '\x487', '\x3', '\x2', '\x2', '\x2', '\x484', '\x487', '\x5', + '\xAA', 'V', '\x2', '\x485', '\x487', '\x5', '\xAC', 'W', '\x2', '\x486', + '\x480', '\x3', '\x2', '\x2', '\x2', '\x486', '\x484', '\x3', '\x2', '\x2', + '\x2', '\x486', '\x485', '\x3', '\x2', '\x2', '\x2', '\x487', '\xA3', + '\x3', '\x2', '\x2', '\x2', '\x488', '\x48D', '\x5', '\xA6', 'T', '\x2', + '\x489', '\x48A', '\a', 'M', '\x2', '\x2', '\x48A', '\x48C', '\x5', '\xA6', + 'T', '\x2', '\x48B', '\x489', '\x3', '\x2', '\x2', '\x2', '\x48C', '\x48F', + '\x3', '\x2', '\x2', '\x2', '\x48D', '\x48B', '\x3', '\x2', '\x2', '\x2', + '\x48D', '\x48E', '\x3', '\x2', '\x2', '\x2', '\x48E', '\x499', '\x3', + '\x2', '\x2', '\x2', '\x48F', '\x48D', '\x3', '\x2', '\x2', '\x2', '\x490', + '\x495', '\x5', '\xAC', 'W', '\x2', '\x491', '\x492', '\a', 'M', '\x2', + '\x2', '\x492', '\x494', '\x5', '\xA6', 'T', '\x2', '\x493', '\x491', + '\x3', '\x2', '\x2', '\x2', '\x494', '\x497', '\x3', '\x2', '\x2', '\x2', + '\x495', '\x493', '\x3', '\x2', '\x2', '\x2', '\x495', '\x496', '\x3', + '\x2', '\x2', '\x2', '\x496', '\x499', '\x3', '\x2', '\x2', '\x2', '\x497', + '\x495', '\x3', '\x2', '\x2', '\x2', '\x498', '\x488', '\x3', '\x2', '\x2', + '\x2', '\x498', '\x490', '\x3', '\x2', '\x2', '\x2', '\x499', '\xA5', + '\x3', '\x2', '\x2', '\x2', '\x49A', '\x49C', '\x5', '\xA8', 'U', '\x2', + '\x49B', '\x49A', '\x3', '\x2', '\x2', '\x2', '\x49C', '\x49F', '\x3', + '\x2', '\x2', '\x2', '\x49D', '\x49B', '\x3', '\x2', '\x2', '\x2', '\x49D', + '\x49E', '\x3', '\x2', '\x2', '\x2', '\x49E', '\x4A0', '\x3', '\x2', '\x2', + '\x2', '\x49F', '\x49D', '\x3', '\x2', '\x2', '\x2', '\x4A0', '\x4A1', + '\x5', '\x80', '\x41', '\x2', '\x4A1', '\x4A2', '\x5', '|', '?', '\x2', + '\x4A2', '\xA7', '\x3', '\x2', '\x2', '\x2', '\x4A3', '\x4A6', '\x5', + '\xF2', 'z', '\x2', '\x4A4', '\x4A6', '\a', '\x15', '\x2', '\x2', '\x4A5', + '\x4A3', '\x3', '\x2', '\x2', '\x2', '\x4A5', '\x4A4', '\x3', '\x2', '\x2', + '\x2', '\x4A6', '\xA9', '\x3', '\x2', '\x2', '\x2', '\x4A7', '\x4A9', + '\x5', '\xA8', 'U', '\x2', '\x4A8', '\x4A7', '\x3', '\x2', '\x2', '\x2', + '\x4A9', '\x4AC', '\x3', '\x2', '\x2', '\x2', '\x4AA', '\x4A8', '\x3', + '\x2', '\x2', '\x2', '\x4AA', '\x4AB', '\x3', '\x2', '\x2', '\x2', '\x4AB', + '\x4AD', '\x3', '\x2', '\x2', '\x2', '\x4AC', '\x4AA', '\x3', '\x2', '\x2', + '\x2', '\x4AD', '\x4B1', '\x5', '\x80', '\x41', '\x2', '\x4AE', '\x4B0', + '\x5', '\xF2', 'z', '\x2', '\x4AF', '\x4AE', '\x3', '\x2', '\x2', '\x2', + '\x4B0', '\x4B3', '\x3', '\x2', '\x2', '\x2', '\x4B1', '\x4AF', '\x3', + '\x2', '\x2', '\x2', '\x4B1', '\x4B2', '\x3', '\x2', '\x2', '\x2', '\x4B2', + '\x4B4', '\x3', '\x2', '\x2', '\x2', '\x4B3', '\x4B1', '\x3', '\x2', '\x2', + '\x2', '\x4B4', '\x4B5', '\a', 'O', '\x2', '\x2', '\x4B5', '\x4B6', '\x5', + '|', '?', '\x2', '\x4B6', '\x4B9', '\x3', '\x2', '\x2', '\x2', '\x4B7', + '\x4B9', '\x5', '\xA6', 'T', '\x2', '\x4B8', '\x4AA', '\x3', '\x2', '\x2', + '\x2', '\x4B8', '\x4B7', '\x3', '\x2', '\x2', '\x2', '\x4B9', '\xAB', + '\x3', '\x2', '\x2', '\x2', '\x4BA', '\x4BC', '\x5', '\xF2', 'z', '\x2', + '\x4BB', '\x4BA', '\x3', '\x2', '\x2', '\x2', '\x4BC', '\x4BF', '\x3', + '\x2', '\x2', '\x2', '\x4BD', '\x4BB', '\x3', '\x2', '\x2', '\x2', '\x4BD', + '\x4BE', '\x3', '\x2', '\x2', '\x2', '\x4BE', '\x4C0', '\x3', '\x2', '\x2', + '\x2', '\x4BF', '\x4BD', '\x3', '\x2', '\x2', '\x2', '\x4C0', '\x4C4', + '\x5', '\x80', '\x41', '\x2', '\x4C1', '\x4C2', '\x5', '\x1EA', '\xF6', + '\x2', '\x4C2', '\x4C3', '\a', 'N', '\x2', '\x2', '\x4C3', '\x4C5', '\x3', + '\x2', '\x2', '\x2', '\x4C4', '\x4C1', '\x3', '\x2', '\x2', '\x2', '\x4C4', + '\x4C5', '\x3', '\x2', '\x2', '\x2', '\x4C5', '\x4C6', '\x3', '\x2', '\x2', + '\x2', '\x4C6', '\x4C7', '\a', '\x33', '\x2', '\x2', '\x4C7', '\xAD', + '\x3', '\x2', '\x2', '\x2', '\x4C8', '\x4C9', '\a', '\x35', '\x2', '\x2', + '\x4C9', '\x4CA', '\x5', '\xB0', 'Y', '\x2', '\x4CA', '\xAF', '\x3', '\x2', + '\x2', '\x2', '\x4CB', '\x4D0', '\x5', '\xB2', 'Z', '\x2', '\x4CC', '\x4CD', + '\a', 'M', '\x2', '\x2', '\x4CD', '\x4CF', '\x5', '\xB2', 'Z', '\x2', + '\x4CE', '\x4CC', '\x3', '\x2', '\x2', '\x2', '\x4CF', '\x4D2', '\x3', + '\x2', '\x2', '\x2', '\x4D0', '\x4CE', '\x3', '\x2', '\x2', '\x2', '\x4D0', + '\x4D1', '\x3', '\x2', '\x2', '\x2', '\x4D1', '\xB1', '\x3', '\x2', '\x2', + '\x2', '\x4D2', '\x4D0', '\x3', '\x2', '\x2', '\x2', '\x4D3', '\x4D6', + '\x5', '\x10', '\t', '\x2', '\x4D4', '\x4D6', '\x5', '\x1C', '\xF', '\x2', + '\x4D5', '\x4D3', '\x3', '\x2', '\x2', '\x2', '\x4D5', '\x4D4', '\x3', + '\x2', '\x2', '\x2', '\x4D6', '\xB3', '\x3', '\x2', '\x2', '\x2', '\x4D7', + '\x4DA', '\x5', '\x108', '\x85', '\x2', '\x4D8', '\x4DA', '\a', 'L', '\x2', + '\x2', '\x4D9', '\x4D7', '\x3', '\x2', '\x2', '\x2', '\x4D9', '\x4D8', + '\x3', '\x2', '\x2', '\x2', '\x4DA', '\xB5', '\x3', '\x2', '\x2', '\x2', + '\x4DB', '\x4DC', '\x5', '\x108', '\x85', '\x2', '\x4DC', '\xB7', '\x3', + '\x2', '\x2', '\x2', '\x4DD', '\x4DE', '\a', '.', '\x2', '\x2', '\x4DE', + '\x4DF', '\x5', '\x108', '\x85', '\x2', '\x4DF', '\xB9', '\x3', '\x2', + '\x2', '\x2', '\x4E0', '\x4E2', '\x5', '\xBC', '_', '\x2', '\x4E1', '\x4E0', + '\x3', '\x2', '\x2', '\x2', '\x4E2', '\x4E5', '\x3', '\x2', '\x2', '\x2', + '\x4E3', '\x4E1', '\x3', '\x2', '\x2', '\x2', '\x4E3', '\x4E4', '\x3', + '\x2', '\x2', '\x2', '\x4E4', '\x4E6', '\x3', '\x2', '\x2', '\x2', '\x4E5', + '\x4E3', '\x3', '\x2', '\x2', '\x2', '\x4E6', '\x4E8', '\x5', '\xBE', + '`', '\x2', '\x4E7', '\x4E9', '\x5', '\xAE', 'X', '\x2', '\x4E8', '\x4E7', + '\x3', '\x2', '\x2', '\x2', '\x4E8', '\x4E9', '\x3', '\x2', '\x2', '\x2', + '\x4E9', '\x4EA', '\x3', '\x2', '\x2', '\x2', '\x4EA', '\x4EB', '\x5', + '\xC2', '\x62', '\x2', '\x4EB', '\xBB', '\x3', '\x2', '\x2', '\x2', '\x4EC', + '\x4F1', '\x5', '\xF2', 'z', '\x2', '\x4ED', '\x4F1', '\a', '*', '\x2', + '\x2', '\x4EE', '\x4F1', '\a', '(', '\x2', '\x2', '\x4EF', '\x4F1', '\a', + '\'', '\x2', '\x2', '\x4F0', '\x4EC', '\x3', '\x2', '\x2', '\x2', '\x4F0', + '\x4ED', '\x3', '\x2', '\x2', '\x2', '\x4F0', '\x4EE', '\x3', '\x2', '\x2', + '\x2', '\x4F0', '\x4EF', '\x3', '\x2', '\x2', '\x2', '\x4F1', '\xBD', + '\x3', '\x2', '\x2', '\x2', '\x4F2', '\x4F4', '\x5', '\x64', '\x33', '\x2', + '\x4F3', '\x4F2', '\x3', '\x2', '\x2', '\x2', '\x4F3', '\x4F4', '\x3', + '\x2', '\x2', '\x2', '\x4F4', '\x4F5', '\x3', '\x2', '\x2', '\x2', '\x4F5', + '\x4F6', '\x5', '\xC0', '\x61', '\x2', '\x4F6', '\x4F8', '\a', '\x46', + '\x2', '\x2', '\x4F7', '\x4F9', '\x5', '\xA2', 'R', '\x2', '\x4F8', '\x4F7', + '\x3', '\x2', '\x2', '\x2', '\x4F8', '\x4F9', '\x3', '\x2', '\x2', '\x2', + '\x4F9', '\x4FA', '\x3', '\x2', '\x2', '\x2', '\x4FA', '\x4FB', '\a', + 'G', '\x2', '\x2', '\x4FB', '\xBF', '\x3', '\x2', '\x2', '\x2', '\x4FC', + '\x4FD', '\x5', '\x1EA', '\xF6', '\x2', '\x4FD', '\xC1', '\x3', '\x2', + '\x2', '\x2', '\x4FE', '\x500', '\a', 'H', '\x2', '\x2', '\x4FF', '\x501', + '\x5', '\xC4', '\x63', '\x2', '\x500', '\x4FF', '\x3', '\x2', '\x2', '\x2', + '\x500', '\x501', '\x3', '\x2', '\x2', '\x2', '\x501', '\x503', '\x3', + '\x2', '\x2', '\x2', '\x502', '\x504', '\x5', '\x10A', '\x86', '\x2', + '\x503', '\x502', '\x3', '\x2', '\x2', '\x2', '\x503', '\x504', '\x3', + '\x2', '\x2', '\x2', '\x504', '\x505', '\x3', '\x2', '\x2', '\x2', '\x505', + '\x506', '\a', 'I', '\x2', '\x2', '\x506', '\xC3', '\x3', '\x2', '\x2', + '\x2', '\x507', '\x509', '\x5', '*', '\x16', '\x2', '\x508', '\x507', + '\x3', '\x2', '\x2', '\x2', '\x508', '\x509', '\x3', '\x2', '\x2', '\x2', + '\x509', '\x50A', '\x3', '\x2', '\x2', '\x2', '\x50A', '\x50B', '\a', + '\x33', '\x2', '\x2', '\x50B', '\x50D', '\a', '\x46', '\x2', '\x2', '\x50C', + '\x50E', '\x5', '\x19E', '\xD0', '\x2', '\x50D', '\x50C', '\x3', '\x2', + '\x2', '\x2', '\x50D', '\x50E', '\x3', '\x2', '\x2', '\x2', '\x50E', '\x50F', + '\x3', '\x2', '\x2', '\x2', '\x50F', '\x510', '\a', 'G', '\x2', '\x2', + '\x510', '\x536', '\a', 'L', '\x2', '\x2', '\x511', '\x513', '\x5', '*', + '\x16', '\x2', '\x512', '\x511', '\x3', '\x2', '\x2', '\x2', '\x512', + '\x513', '\x3', '\x2', '\x2', '\x2', '\x513', '\x514', '\x3', '\x2', '\x2', + '\x2', '\x514', '\x515', '\a', '\x30', '\x2', '\x2', '\x515', '\x517', + '\a', '\x46', '\x2', '\x2', '\x516', '\x518', '\x5', '\x19E', '\xD0', + '\x2', '\x517', '\x516', '\x3', '\x2', '\x2', '\x2', '\x517', '\x518', + '\x3', '\x2', '\x2', '\x2', '\x518', '\x519', '\x3', '\x2', '\x2', '\x2', + '\x519', '\x51A', '\a', 'G', '\x2', '\x2', '\x51A', '\x536', '\a', 'L', + '\x2', '\x2', '\x51B', '\x51C', '\x5', '<', '\x1F', '\x2', '\x51C', '\x51E', + '\a', 'N', '\x2', '\x2', '\x51D', '\x51F', '\x5', '*', '\x16', '\x2', + '\x51E', '\x51D', '\x3', '\x2', '\x2', '\x2', '\x51E', '\x51F', '\x3', + '\x2', '\x2', '\x2', '\x51F', '\x520', '\x3', '\x2', '\x2', '\x2', '\x520', + '\x521', '\a', '\x30', '\x2', '\x2', '\x521', '\x523', '\a', '\x46', '\x2', + '\x2', '\x522', '\x524', '\x5', '\x19E', '\xD0', '\x2', '\x523', '\x522', + '\x3', '\x2', '\x2', '\x2', '\x523', '\x524', '\x3', '\x2', '\x2', '\x2', + '\x524', '\x525', '\x3', '\x2', '\x2', '\x2', '\x525', '\x526', '\a', + 'G', '\x2', '\x2', '\x526', '\x527', '\a', 'L', '\x2', '\x2', '\x527', + '\x536', '\x3', '\x2', '\x2', '\x2', '\x528', '\x529', '\x5', '\x16E', + '\xB8', '\x2', '\x529', '\x52B', '\a', 'N', '\x2', '\x2', '\x52A', '\x52C', + '\x5', '*', '\x16', '\x2', '\x52B', '\x52A', '\x3', '\x2', '\x2', '\x2', + '\x52B', '\x52C', '\x3', '\x2', '\x2', '\x2', '\x52C', '\x52D', '\x3', + '\x2', '\x2', '\x2', '\x52D', '\x52E', '\a', '\x30', '\x2', '\x2', '\x52E', + '\x530', '\a', '\x46', '\x2', '\x2', '\x52F', '\x531', '\x5', '\x19E', + '\xD0', '\x2', '\x530', '\x52F', '\x3', '\x2', '\x2', '\x2', '\x530', + '\x531', '\x3', '\x2', '\x2', '\x2', '\x531', '\x532', '\x3', '\x2', '\x2', + '\x2', '\x532', '\x533', '\a', 'G', '\x2', '\x2', '\x533', '\x534', '\a', + 'L', '\x2', '\x2', '\x534', '\x536', '\x3', '\x2', '\x2', '\x2', '\x535', + '\x508', '\x3', '\x2', '\x2', '\x2', '\x535', '\x512', '\x3', '\x2', '\x2', + '\x2', '\x535', '\x51B', '\x3', '\x2', '\x2', '\x2', '\x535', '\x528', + '\x3', '\x2', '\x2', '\x2', '\x536', '\xC5', '\x3', '\x2', '\x2', '\x2', + '\x537', '\x539', '\x5', '\x62', '\x32', '\x2', '\x538', '\x537', '\x3', + '\x2', '\x2', '\x2', '\x539', '\x53C', '\x3', '\x2', '\x2', '\x2', '\x53A', + '\x538', '\x3', '\x2', '\x2', '\x2', '\x53A', '\x53B', '\x3', '\x2', '\x2', + '\x2', '\x53B', '\x53D', '\x3', '\x2', '\x2', '\x2', '\x53C', '\x53A', + '\x3', '\x2', '\x2', '\x2', '\x53D', '\x53E', '\a', '\x12', '\x2', '\x2', + '\x53E', '\x540', '\x5', '\x1EA', '\xF6', '\x2', '\x53F', '\x541', '\x5', + 'j', '\x36', '\x2', '\x540', '\x53F', '\x3', '\x2', '\x2', '\x2', '\x540', + '\x541', '\x3', '\x2', '\x2', '\x2', '\x541', '\x542', '\x3', '\x2', '\x2', + '\x2', '\x542', '\x543', '\x5', '\xC8', '\x65', '\x2', '\x543', '\xC7', + '\x3', '\x2', '\x2', '\x2', '\x544', '\x546', '\a', 'H', '\x2', '\x2', + '\x545', '\x547', '\x5', '\xCA', '\x66', '\x2', '\x546', '\x545', '\x3', + '\x2', '\x2', '\x2', '\x546', '\x547', '\x3', '\x2', '\x2', '\x2', '\x547', + '\x549', '\x3', '\x2', '\x2', '\x2', '\x548', '\x54A', '\a', 'M', '\x2', + '\x2', '\x549', '\x548', '\x3', '\x2', '\x2', '\x2', '\x549', '\x54A', + '\x3', '\x2', '\x2', '\x2', '\x54A', '\x54C', '\x3', '\x2', '\x2', '\x2', + '\x54B', '\x54D', '\x5', '\xD0', 'i', '\x2', '\x54C', '\x54B', '\x3', + '\x2', '\x2', '\x2', '\x54C', '\x54D', '\x3', '\x2', '\x2', '\x2', '\x54D', + '\x54E', '\x3', '\x2', '\x2', '\x2', '\x54E', '\x54F', '\a', 'I', '\x2', + '\x2', '\x54F', '\xC9', '\x3', '\x2', '\x2', '\x2', '\x550', '\x555', + '\x5', '\xCC', 'g', '\x2', '\x551', '\x552', '\a', 'M', '\x2', '\x2', + '\x552', '\x554', '\x5', '\xCC', 'g', '\x2', '\x553', '\x551', '\x3', + '\x2', '\x2', '\x2', '\x554', '\x557', '\x3', '\x2', '\x2', '\x2', '\x555', + '\x553', '\x3', '\x2', '\x2', '\x2', '\x555', '\x556', '\x3', '\x2', '\x2', + '\x2', '\x556', '\xCB', '\x3', '\x2', '\x2', '\x2', '\x557', '\x555', + '\x3', '\x2', '\x2', '\x2', '\x558', '\x55A', '\x5', '\xCE', 'h', '\x2', + '\x559', '\x558', '\x3', '\x2', '\x2', '\x2', '\x55A', '\x55D', '\x3', + '\x2', '\x2', '\x2', '\x55B', '\x559', '\x3', '\x2', '\x2', '\x2', '\x55B', + '\x55C', '\x3', '\x2', '\x2', '\x2', '\x55C', '\x55E', '\x3', '\x2', '\x2', + '\x2', '\x55D', '\x55B', '\x3', '\x2', '\x2', '\x2', '\x55E', '\x564', + '\x5', '\x1EA', '\xF6', '\x2', '\x55F', '\x561', '\a', '\x46', '\x2', + '\x2', '\x560', '\x562', '\x5', '\x19E', '\xD0', '\x2', '\x561', '\x560', + '\x3', '\x2', '\x2', '\x2', '\x561', '\x562', '\x3', '\x2', '\x2', '\x2', + '\x562', '\x563', '\x3', '\x2', '\x2', '\x2', '\x563', '\x565', '\a', + 'G', '\x2', '\x2', '\x564', '\x55F', '\x3', '\x2', '\x2', '\x2', '\x564', + '\x565', '\x3', '\x2', '\x2', '\x2', '\x565', '\x567', '\x3', '\x2', '\x2', + '\x2', '\x566', '\x568', '\x5', 'n', '\x38', '\x2', '\x567', '\x566', + '\x3', '\x2', '\x2', '\x2', '\x567', '\x568', '\x3', '\x2', '\x2', '\x2', + '\x568', '\xCD', '\x3', '\x2', '\x2', '\x2', '\x569', '\x56A', '\x5', + '\xF2', 'z', '\x2', '\x56A', '\xCF', '\x3', '\x2', '\x2', '\x2', '\x56B', + '\x56F', '\a', 'L', '\x2', '\x2', '\x56C', '\x56E', '\x5', 'p', '\x39', + '\x2', '\x56D', '\x56C', '\x3', '\x2', '\x2', '\x2', '\x56E', '\x571', + '\x3', '\x2', '\x2', '\x2', '\x56F', '\x56D', '\x3', '\x2', '\x2', '\x2', + '\x56F', '\x570', '\x3', '\x2', '\x2', '\x2', '\x570', '\xD1', '\x3', + '\x2', '\x2', '\x2', '\x571', '\x56F', '\x3', '\x2', '\x2', '\x2', '\x572', + '\x575', '\x5', '\xD4', 'k', '\x2', '\x573', '\x575', '\x5', '\xE6', 't', + '\x2', '\x574', '\x572', '\x3', '\x2', '\x2', '\x2', '\x574', '\x573', + '\x3', '\x2', '\x2', '\x2', '\x575', '\xD3', '\x3', '\x2', '\x2', '\x2', + '\x576', '\x578', '\x5', '\xD6', 'l', '\x2', '\x577', '\x576', '\x3', + '\x2', '\x2', '\x2', '\x578', '\x57B', '\x3', '\x2', '\x2', '\x2', '\x579', + '\x577', '\x3', '\x2', '\x2', '\x2', '\x579', '\x57A', '\x3', '\x2', '\x2', + '\x2', '\x57A', '\x57C', '\x3', '\x2', '\x2', '\x2', '\x57B', '\x579', + '\x3', '\x2', '\x2', '\x2', '\x57C', '\x57D', '\a', '\x1F', '\x2', '\x2', + '\x57D', '\x57F', '\x5', '\x1EA', '\xF6', '\x2', '\x57E', '\x580', '\x5', + '\x64', '\x33', '\x2', '\x57F', '\x57E', '\x3', '\x2', '\x2', '\x2', '\x57F', + '\x580', '\x3', '\x2', '\x2', '\x2', '\x580', '\x582', '\x3', '\x2', '\x2', + '\x2', '\x581', '\x583', '\x5', '\xD8', 'm', '\x2', '\x582', '\x581', + '\x3', '\x2', '\x2', '\x2', '\x582', '\x583', '\x3', '\x2', '\x2', '\x2', + '\x583', '\x584', '\x3', '\x2', '\x2', '\x2', '\x584', '\x585', '\x5', + '\xDA', 'n', '\x2', '\x585', '\xD5', '\x3', '\x2', '\x2', '\x2', '\x586', + '\x58E', '\x5', '\xF2', 'z', '\x2', '\x587', '\x58E', '\a', '*', '\x2', + '\x2', '\x588', '\x58E', '\a', '(', '\x2', '\x2', '\x589', '\x58E', '\a', + '\'', '\x2', '\x2', '\x58A', '\x58E', '\a', '\x3', '\x2', '\x2', '\x58B', + '\x58E', '\a', '.', '\x2', '\x2', '\x58C', '\x58E', '\a', '/', '\x2', + '\x2', '\x58D', '\x586', '\x3', '\x2', '\x2', '\x2', '\x58D', '\x587', + '\x3', '\x2', '\x2', '\x2', '\x58D', '\x588', '\x3', '\x2', '\x2', '\x2', + '\x58D', '\x589', '\x3', '\x2', '\x2', '\x2', '\x58D', '\x58A', '\x3', + '\x2', '\x2', '\x2', '\x58D', '\x58B', '\x3', '\x2', '\x2', '\x2', '\x58D', + '\x58C', '\x3', '\x2', '\x2', '\x2', '\x58E', '\xD7', '\x3', '\x2', '\x2', + '\x2', '\x58F', '\x590', '\a', '\x14', '\x2', '\x2', '\x590', '\x591', + '\x5', 'l', '\x37', '\x2', '\x591', '\xD9', '\x3', '\x2', '\x2', '\x2', + '\x592', '\x596', '\a', 'H', '\x2', '\x2', '\x593', '\x595', '\x5', '\xDC', + 'o', '\x2', '\x594', '\x593', '\x3', '\x2', '\x2', '\x2', '\x595', '\x598', + '\x3', '\x2', '\x2', '\x2', '\x596', '\x594', '\x3', '\x2', '\x2', '\x2', + '\x596', '\x597', '\x3', '\x2', '\x2', '\x2', '\x597', '\x599', '\x3', + '\x2', '\x2', '\x2', '\x598', '\x596', '\x3', '\x2', '\x2', '\x2', '\x599', + '\x59A', '\a', 'I', '\x2', '\x2', '\x59A', '\xDB', '\x3', '\x2', '\x2', + '\x2', '\x59B', '\x5A1', '\x5', '\xDE', 'p', '\x2', '\x59C', '\x5A1', + '\x5', '\xE2', 'r', '\x2', '\x59D', '\x5A1', '\x5', '^', '\x30', '\x2', + '\x59E', '\x5A1', '\x5', '\xD2', 'j', '\x2', '\x59F', '\x5A1', '\a', 'L', + '\x2', '\x2', '\x5A0', '\x59B', '\x3', '\x2', '\x2', '\x2', '\x5A0', '\x59C', + '\x3', '\x2', '\x2', '\x2', '\x5A0', '\x59D', '\x3', '\x2', '\x2', '\x2', + '\x5A0', '\x59E', '\x3', '\x2', '\x2', '\x2', '\x5A0', '\x59F', '\x3', + '\x2', '\x2', '\x2', '\x5A1', '\xDD', '\x3', '\x2', '\x2', '\x2', '\x5A2', + '\x5A4', '\x5', '\xE0', 'q', '\x2', '\x5A3', '\x5A2', '\x3', '\x2', '\x2', + '\x2', '\x5A4', '\x5A7', '\x3', '\x2', '\x2', '\x2', '\x5A5', '\x5A3', + '\x3', '\x2', '\x2', '\x2', '\x5A5', '\x5A6', '\x3', '\x2', '\x2', '\x2', + '\x5A6', '\x5A8', '\x3', '\x2', '\x2', '\x2', '\x5A7', '\x5A5', '\x3', + '\x2', '\x2', '\x2', '\x5A8', '\x5A9', '\x5', '\x80', '\x41', '\x2', '\x5A9', + '\x5AA', '\x5', 'x', '=', '\x2', '\x5AA', '\x5AB', '\a', 'L', '\x2', '\x2', + '\x5AB', '\xDF', '\x3', '\x2', '\x2', '\x2', '\x5AC', '\x5B1', '\x5', + '\xF2', 'z', '\x2', '\x5AD', '\x5B1', '\a', '*', '\x2', '\x2', '\x5AE', + '\x5B1', '\a', '.', '\x2', '\x2', '\x5AF', '\x5B1', '\a', '\x15', '\x2', + '\x2', '\x5B0', '\x5AC', '\x3', '\x2', '\x2', '\x2', '\x5B0', '\x5AD', + '\x3', '\x2', '\x2', '\x2', '\x5B0', '\x5AE', '\x3', '\x2', '\x2', '\x2', + '\x5B0', '\x5AF', '\x3', '\x2', '\x2', '\x2', '\x5B1', '\xE1', '\x3', + '\x2', '\x2', '\x2', '\x5B2', '\x5B4', '\x5', '\xE4', 's', '\x2', '\x5B3', + '\x5B2', '\x3', '\x2', '\x2', '\x2', '\x5B4', '\x5B7', '\x3', '\x2', '\x2', + '\x2', '\x5B5', '\x5B3', '\x3', '\x2', '\x2', '\x2', '\x5B5', '\x5B6', + '\x3', '\x2', '\x2', '\x2', '\x5B6', '\x5B8', '\x3', '\x2', '\x2', '\x2', + '\x5B7', '\x5B5', '\x3', '\x2', '\x2', '\x2', '\x5B8', '\x5B9', '\x5', + '\x9C', 'O', '\x2', '\x5B9', '\x5BA', '\x5', '\xB4', '[', '\x2', '\x5BA', + '\xE3', '\x3', '\x2', '\x2', '\x2', '\x5BB', '\x5C3', '\x5', '\xF2', 'z', + '\x2', '\x5BC', '\x5C3', '\a', '*', '\x2', '\x2', '\x5BD', '\x5C3', '\a', + '\'', '\x2', '\x2', '\x5BE', '\x5C3', '\a', '\x3', '\x2', '\x2', '\x5BF', + '\x5C3', '\a', '\xE', '\x2', '\x2', '\x5C0', '\x5C3', '\a', '.', '\x2', + '\x2', '\x5C1', '\x5C3', '\a', '/', '\x2', '\x2', '\x5C2', '\x5BB', '\x3', + '\x2', '\x2', '\x2', '\x5C2', '\x5BC', '\x3', '\x2', '\x2', '\x2', '\x5C2', + '\x5BD', '\x3', '\x2', '\x2', '\x2', '\x5C2', '\x5BE', '\x3', '\x2', '\x2', + '\x2', '\x5C2', '\x5BF', '\x3', '\x2', '\x2', '\x2', '\x5C2', '\x5C0', + '\x3', '\x2', '\x2', '\x2', '\x5C2', '\x5C1', '\x3', '\x2', '\x2', '\x2', + '\x5C3', '\xE5', '\x3', '\x2', '\x2', '\x2', '\x5C4', '\x5C6', '\x5', + '\xD6', 'l', '\x2', '\x5C5', '\x5C4', '\x3', '\x2', '\x2', '\x2', '\x5C6', + '\x5C9', '\x3', '\x2', '\x2', '\x2', '\x5C7', '\x5C5', '\x3', '\x2', '\x2', + '\x2', '\x5C7', '\x5C8', '\x3', '\x2', '\x2', '\x2', '\x5C8', '\x5CA', + '\x3', '\x2', '\x2', '\x2', '\x5C9', '\x5C7', '\x3', '\x2', '\x2', '\x2', + '\x5CA', '\x5CB', '\a', 'P', '\x2', '\x2', '\x5CB', '\x5CC', '\a', '\x1F', + '\x2', '\x2', '\x5CC', '\x5CD', '\x5', '\x1EA', '\xF6', '\x2', '\x5CD', + '\x5CE', '\x5', '\xE8', 'u', '\x2', '\x5CE', '\xE7', '\x3', '\x2', '\x2', + '\x2', '\x5CF', '\x5D3', '\a', 'H', '\x2', '\x2', '\x5D0', '\x5D2', '\x5', + '\xEA', 'v', '\x2', '\x5D1', '\x5D0', '\x3', '\x2', '\x2', '\x2', '\x5D2', + '\x5D5', '\x3', '\x2', '\x2', '\x2', '\x5D3', '\x5D1', '\x3', '\x2', '\x2', + '\x2', '\x5D3', '\x5D4', '\x3', '\x2', '\x2', '\x2', '\x5D4', '\x5D6', + '\x3', '\x2', '\x2', '\x2', '\x5D5', '\x5D3', '\x3', '\x2', '\x2', '\x2', + '\x5D6', '\x5D7', '\a', 'I', '\x2', '\x2', '\x5D7', '\xE9', '\x3', '\x2', + '\x2', '\x2', '\x5D8', '\x5DE', '\x5', '\xEC', 'w', '\x2', '\x5D9', '\x5DE', + '\x5', '\xDE', 'p', '\x2', '\x5DA', '\x5DE', '\x5', '^', '\x30', '\x2', + '\x5DB', '\x5DE', '\x5', '\xD2', 'j', '\x2', '\x5DC', '\x5DE', '\a', 'L', + '\x2', '\x2', '\x5DD', '\x5D8', '\x3', '\x2', '\x2', '\x2', '\x5DD', '\x5D9', + '\x3', '\x2', '\x2', '\x2', '\x5DD', '\x5DA', '\x3', '\x2', '\x2', '\x2', + '\x5DD', '\x5DB', '\x3', '\x2', '\x2', '\x2', '\x5DD', '\x5DC', '\x3', + '\x2', '\x2', '\x2', '\x5DE', '\xEB', '\x3', '\x2', '\x2', '\x2', '\x5DF', + '\x5E1', '\x5', '\xEE', 'x', '\x2', '\x5E0', '\x5DF', '\x3', '\x2', '\x2', + '\x2', '\x5E1', '\x5E4', '\x3', '\x2', '\x2', '\x2', '\x5E2', '\x5E0', + '\x3', '\x2', '\x2', '\x2', '\x5E2', '\x5E3', '\x3', '\x2', '\x2', '\x2', + '\x5E3', '\x5E5', '\x3', '\x2', '\x2', '\x2', '\x5E4', '\x5E2', '\x3', + '\x2', '\x2', '\x2', '\x5E5', '\x5E6', '\x5', '\x80', '\x41', '\x2', '\x5E6', + '\x5E7', '\x5', '\x1EA', '\xF6', '\x2', '\x5E7', '\x5E8', '\a', '\x46', + '\x2', '\x2', '\x5E8', '\x5EA', '\a', 'G', '\x2', '\x2', '\x5E9', '\x5EB', + '\x5', ' ', '\x11', '\x2', '\x5EA', '\x5E9', '\x3', '\x2', '\x2', '\x2', + '\x5EA', '\x5EB', '\x3', '\x2', '\x2', '\x2', '\x5EB', '\x5ED', '\x3', + '\x2', '\x2', '\x2', '\x5EC', '\x5EE', '\x5', '\xF0', 'y', '\x2', '\x5ED', + '\x5EC', '\x3', '\x2', '\x2', '\x2', '\x5ED', '\x5EE', '\x3', '\x2', '\x2', + '\x2', '\x5EE', '\x5EF', '\x3', '\x2', '\x2', '\x2', '\x5EF', '\x5F0', + '\a', 'L', '\x2', '\x2', '\x5F0', '\xED', '\x3', '\x2', '\x2', '\x2', + '\x5F1', '\x5F5', '\x5', '\xF2', 'z', '\x2', '\x5F2', '\x5F5', '\a', '*', + '\x2', '\x2', '\x5F3', '\x5F5', '\a', '\x3', '\x2', '\x2', '\x5F4', '\x5F1', + '\x3', '\x2', '\x2', '\x2', '\x5F4', '\x5F2', '\x3', '\x2', '\x2', '\x2', + '\x5F4', '\x5F3', '\x3', '\x2', '\x2', '\x2', '\x5F5', '\xEF', '\x3', + '\x2', '\x2', '\x2', '\x5F6', '\x5F7', '\a', '\xE', '\x2', '\x2', '\x5F7', + '\x5F8', '\x5', '\xFA', '~', '\x2', '\x5F8', '\xF1', '\x3', '\x2', '\x2', + '\x2', '\x5F9', '\x5FD', '\x5', '\xF4', '{', '\x2', '\x5FA', '\x5FD', + '\x5', '\x100', '\x81', '\x2', '\x5FB', '\x5FD', '\x5', '\x102', '\x82', + '\x2', '\x5FC', '\x5F9', '\x3', '\x2', '\x2', '\x2', '\x5FC', '\x5FA', + '\x3', '\x2', '\x2', '\x2', '\x5FC', '\x5FB', '\x3', '\x2', '\x2', '\x2', + '\x5FD', '\xF3', '\x3', '\x2', '\x2', '\x2', '\x5FE', '\x5FF', '\a', 'P', + '\x2', '\x2', '\x5FF', '\x600', '\x5', '\x38', '\x1D', '\x2', '\x600', + '\x602', '\a', '\x46', '\x2', '\x2', '\x601', '\x603', '\x5', '\xF6', + '|', '\x2', '\x602', '\x601', '\x3', '\x2', '\x2', '\x2', '\x602', '\x603', + '\x3', '\x2', '\x2', '\x2', '\x603', '\x604', '\x3', '\x2', '\x2', '\x2', + '\x604', '\x605', '\a', 'G', '\x2', '\x2', '\x605', '\xF5', '\x3', '\x2', + '\x2', '\x2', '\x606', '\x60B', '\x5', '\xF8', '}', '\x2', '\x607', '\x608', + '\a', 'M', '\x2', '\x2', '\x608', '\x60A', '\x5', '\xF8', '}', '\x2', + '\x609', '\x607', '\x3', '\x2', '\x2', '\x2', '\x60A', '\x60D', '\x3', + '\x2', '\x2', '\x2', '\x60B', '\x609', '\x3', '\x2', '\x2', '\x2', '\x60B', + '\x60C', '\x3', '\x2', '\x2', '\x2', '\x60C', '\xF7', '\x3', '\x2', '\x2', + '\x2', '\x60D', '\x60B', '\x3', '\x2', '\x2', '\x2', '\x60E', '\x60F', + '\x5', '\x1EA', '\xF6', '\x2', '\x60F', '\x610', '\a', 'R', '\x2', '\x2', + '\x610', '\x611', '\x5', '\xFA', '~', '\x2', '\x611', '\xF9', '\x3', '\x2', + '\x2', '\x2', '\x612', '\x616', '\x5', '\x1C0', '\xE1', '\x2', '\x613', + '\x616', '\x5', '\xFC', '\x7F', '\x2', '\x614', '\x616', '\x5', '\xF2', + 'z', '\x2', '\x615', '\x612', '\x3', '\x2', '\x2', '\x2', '\x615', '\x613', + '\x3', '\x2', '\x2', '\x2', '\x615', '\x614', '\x3', '\x2', '\x2', '\x2', + '\x616', '\xFB', '\x3', '\x2', '\x2', '\x2', '\x617', '\x619', '\a', 'H', + '\x2', '\x2', '\x618', '\x61A', '\x5', '\xFE', '\x80', '\x2', '\x619', + '\x618', '\x3', '\x2', '\x2', '\x2', '\x619', '\x61A', '\x3', '\x2', '\x2', + '\x2', '\x61A', '\x61C', '\x3', '\x2', '\x2', '\x2', '\x61B', '\x61D', + '\a', 'M', '\x2', '\x2', '\x61C', '\x61B', '\x3', '\x2', '\x2', '\x2', + '\x61C', '\x61D', '\x3', '\x2', '\x2', '\x2', '\x61D', '\x61E', '\x3', + '\x2', '\x2', '\x2', '\x61E', '\x61F', '\a', 'I', '\x2', '\x2', '\x61F', + '\xFD', '\x3', '\x2', '\x2', '\x2', '\x620', '\x625', '\x5', '\xFA', '~', + '\x2', '\x621', '\x622', '\a', 'M', '\x2', '\x2', '\x622', '\x624', '\x5', + '\xFA', '~', '\x2', '\x623', '\x621', '\x3', '\x2', '\x2', '\x2', '\x624', + '\x627', '\x3', '\x2', '\x2', '\x2', '\x625', '\x623', '\x3', '\x2', '\x2', + '\x2', '\x625', '\x626', '\x3', '\x2', '\x2', '\x2', '\x626', '\xFF', + '\x3', '\x2', '\x2', '\x2', '\x627', '\x625', '\x3', '\x2', '\x2', '\x2', + '\x628', '\x629', '\a', 'P', '\x2', '\x2', '\x629', '\x62A', '\x5', '\x38', + '\x1D', '\x2', '\x62A', '\x101', '\x3', '\x2', '\x2', '\x2', '\x62B', + '\x62C', '\a', 'P', '\x2', '\x2', '\x62C', '\x62D', '\x5', '\x38', '\x1D', + '\x2', '\x62D', '\x62E', '\a', '\x46', '\x2', '\x2', '\x62E', '\x62F', + '\x5', '\xFA', '~', '\x2', '\x62F', '\x630', '\a', 'G', '\x2', '\x2', + '\x630', '\x103', '\x3', '\x2', '\x2', '\x2', '\x631', '\x633', '\a', + 'H', '\x2', '\x2', '\x632', '\x634', '\x5', '\x106', '\x84', '\x2', '\x633', + '\x632', '\x3', '\x2', '\x2', '\x2', '\x633', '\x634', '\x3', '\x2', '\x2', + '\x2', '\x634', '\x636', '\x3', '\x2', '\x2', '\x2', '\x635', '\x637', + '\a', 'M', '\x2', '\x2', '\x636', '\x635', '\x3', '\x2', '\x2', '\x2', + '\x636', '\x637', '\x3', '\x2', '\x2', '\x2', '\x637', '\x638', '\x3', + '\x2', '\x2', '\x2', '\x638', '\x639', '\a', 'I', '\x2', '\x2', '\x639', + '\x105', '\x3', '\x2', '\x2', '\x2', '\x63A', '\x63F', '\x5', '~', '@', + '\x2', '\x63B', '\x63C', '\a', 'M', '\x2', '\x2', '\x63C', '\x63E', '\x5', + '~', '@', '\x2', '\x63D', '\x63B', '\x3', '\x2', '\x2', '\x2', '\x63E', + '\x641', '\x3', '\x2', '\x2', '\x2', '\x63F', '\x63D', '\x3', '\x2', '\x2', + '\x2', '\x63F', '\x640', '\x3', '\x2', '\x2', '\x2', '\x640', '\x107', + '\x3', '\x2', '\x2', '\x2', '\x641', '\x63F', '\x3', '\x2', '\x2', '\x2', + '\x642', '\x644', '\a', 'H', '\x2', '\x2', '\x643', '\x645', '\x5', '\x10A', + '\x86', '\x2', '\x644', '\x643', '\x3', '\x2', '\x2', '\x2', '\x644', + '\x645', '\x3', '\x2', '\x2', '\x2', '\x645', '\x646', '\x3', '\x2', '\x2', + '\x2', '\x646', '\x647', '\a', 'I', '\x2', '\x2', '\x647', '\x109', '\x3', + '\x2', '\x2', '\x2', '\x648', '\x64A', '\x5', '\x10C', '\x87', '\x2', + '\x649', '\x648', '\x3', '\x2', '\x2', '\x2', '\x64A', '\x64B', '\x3', + '\x2', '\x2', '\x2', '\x64B', '\x649', '\x3', '\x2', '\x2', '\x2', '\x64B', + '\x64C', '\x3', '\x2', '\x2', '\x2', '\x64C', '\x10B', '\x3', '\x2', '\x2', + '\x2', '\x64D', '\x651', '\x5', '\x10E', '\x88', '\x2', '\x64E', '\x651', + '\x5', '^', '\x30', '\x2', '\x64F', '\x651', '\x5', '\x112', '\x8A', '\x2', + '\x650', '\x64D', '\x3', '\x2', '\x2', '\x2', '\x650', '\x64E', '\x3', + '\x2', '\x2', '\x2', '\x650', '\x64F', '\x3', '\x2', '\x2', '\x2', '\x651', + '\x10D', '\x3', '\x2', '\x2', '\x2', '\x652', '\x653', '\x5', '\x110', + '\x89', '\x2', '\x653', '\x654', '\a', 'L', '\x2', '\x2', '\x654', '\x10F', + '\x3', '\x2', '\x2', '\x2', '\x655', '\x657', '\x5', '\xA8', 'U', '\x2', + '\x656', '\x655', '\x3', '\x2', '\x2', '\x2', '\x657', '\x65A', '\x3', + '\x2', '\x2', '\x2', '\x658', '\x656', '\x3', '\x2', '\x2', '\x2', '\x658', + '\x659', '\x3', '\x2', '\x2', '\x2', '\x659', '\x65B', '\x3', '\x2', '\x2', + '\x2', '\x65A', '\x658', '\x3', '\x2', '\x2', '\x2', '\x65B', '\x65C', + '\x5', '\x80', '\x41', '\x2', '\x65C', '\x65D', '\x5', 'x', '=', '\x2', + '\x65D', '\x111', '\x3', '\x2', '\x2', '\x2', '\x65E', '\x665', '\x5', + '\x116', '\x8C', '\x2', '\x65F', '\x665', '\x5', '\x11A', '\x8E', '\x2', + '\x660', '\x665', '\x5', '\x122', '\x92', '\x2', '\x661', '\x665', '\x5', + '\x124', '\x93', '\x2', '\x662', '\x665', '\x5', '\x136', '\x9C', '\x2', + '\x663', '\x665', '\x5', '\x13C', '\x9F', '\x2', '\x664', '\x65E', '\x3', + '\x2', '\x2', '\x2', '\x664', '\x65F', '\x3', '\x2', '\x2', '\x2', '\x664', + '\x660', '\x3', '\x2', '\x2', '\x2', '\x664', '\x661', '\x3', '\x2', '\x2', + '\x2', '\x664', '\x662', '\x3', '\x2', '\x2', '\x2', '\x664', '\x663', + '\x3', '\x2', '\x2', '\x2', '\x665', '\x113', '\x3', '\x2', '\x2', '\x2', + '\x666', '\x66C', '\x5', '\x116', '\x8C', '\x2', '\x667', '\x66C', '\x5', + '\x11C', '\x8F', '\x2', '\x668', '\x66C', '\x5', '\x126', '\x94', '\x2', + '\x669', '\x66C', '\x5', '\x138', '\x9D', '\x2', '\x66A', '\x66C', '\x5', + '\x13E', '\xA0', '\x2', '\x66B', '\x666', '\x3', '\x2', '\x2', '\x2', + '\x66B', '\x667', '\x3', '\x2', '\x2', '\x2', '\x66B', '\x668', '\x3', + '\x2', '\x2', '\x2', '\x66B', '\x669', '\x3', '\x2', '\x2', '\x2', '\x66B', + '\x66A', '\x3', '\x2', '\x2', '\x2', '\x66C', '\x115', '\x3', '\x2', '\x2', + '\x2', '\x66D', '\x67A', '\x5', '\x108', '\x85', '\x2', '\x66E', '\x67A', + '\x5', '\x118', '\x8D', '\x2', '\x66F', '\x67A', '\x5', '\x11E', '\x90', + '\x2', '\x670', '\x67A', '\x5', '\x128', '\x95', '\x2', '\x671', '\x67A', + '\x5', '\x12A', '\x96', '\x2', '\x672', '\x67A', '\x5', '\x13A', '\x9E', + '\x2', '\x673', '\x67A', '\x5', '\x14E', '\xA8', '\x2', '\x674', '\x67A', + '\x5', '\x150', '\xA9', '\x2', '\x675', '\x67A', '\x5', '\x152', '\xAA', + '\x2', '\x676', '\x67A', '\x5', '\x156', '\xAC', '\x2', '\x677', '\x67A', + '\x5', '\x154', '\xAB', '\x2', '\x678', '\x67A', '\x5', '\x158', '\xAD', + '\x2', '\x679', '\x66D', '\x3', '\x2', '\x2', '\x2', '\x679', '\x66E', + '\x3', '\x2', '\x2', '\x2', '\x679', '\x66F', '\x3', '\x2', '\x2', '\x2', + '\x679', '\x670', '\x3', '\x2', '\x2', '\x2', '\x679', '\x671', '\x3', + '\x2', '\x2', '\x2', '\x679', '\x672', '\x3', '\x2', '\x2', '\x2', '\x679', + '\x673', '\x3', '\x2', '\x2', '\x2', '\x679', '\x674', '\x3', '\x2', '\x2', + '\x2', '\x679', '\x675', '\x3', '\x2', '\x2', '\x2', '\x679', '\x676', + '\x3', '\x2', '\x2', '\x2', '\x679', '\x677', '\x3', '\x2', '\x2', '\x2', + '\x679', '\x678', '\x3', '\x2', '\x2', '\x2', '\x67A', '\x117', '\x3', + '\x2', '\x2', '\x2', '\x67B', '\x67C', '\a', 'L', '\x2', '\x2', '\x67C', + '\x119', '\x3', '\x2', '\x2', '\x2', '\x67D', '\x67E', '\x5', '\x1EA', + '\xF6', '\x2', '\x67E', '\x67F', '\a', 'X', '\x2', '\x2', '\x67F', '\x680', + '\x5', '\x112', '\x8A', '\x2', '\x680', '\x11B', '\x3', '\x2', '\x2', + '\x2', '\x681', '\x682', '\x5', '\x1EA', '\xF6', '\x2', '\x682', '\x683', + '\a', 'X', '\x2', '\x2', '\x683', '\x684', '\x5', '\x114', '\x8B', '\x2', + '\x684', '\x11D', '\x3', '\x2', '\x2', '\x2', '\x685', '\x686', '\x5', + '\x120', '\x91', '\x2', '\x686', '\x687', '\a', 'L', '\x2', '\x2', '\x687', + '\x11F', '\x3', '\x2', '\x2', '\x2', '\x688', '\x690', '\x5', '\x1BA', + '\xDE', '\x2', '\x689', '\x690', '\x5', '\x1D8', '\xED', '\x2', '\x68A', + '\x690', '\x5', '\x1DA', '\xEE', '\x2', '\x68B', '\x690', '\x5', '\x1E0', + '\xF1', '\x2', '\x68C', '\x690', '\x5', '\x1E4', '\xF3', '\x2', '\x68D', + '\x690', '\x5', '\x198', '\xCD', '\x2', '\x68E', '\x690', '\x5', '\x184', + '\xC3', '\x2', '\x68F', '\x688', '\x3', '\x2', '\x2', '\x2', '\x68F', + '\x689', '\x3', '\x2', '\x2', '\x2', '\x68F', '\x68A', '\x3', '\x2', '\x2', + '\x2', '\x68F', '\x68B', '\x3', '\x2', '\x2', '\x2', '\x68F', '\x68C', + '\x3', '\x2', '\x2', '\x2', '\x68F', '\x68D', '\x3', '\x2', '\x2', '\x2', + '\x68F', '\x68E', '\x3', '\x2', '\x2', '\x2', '\x690', '\x121', '\x3', + '\x2', '\x2', '\x2', '\x691', '\x692', '\a', '\x19', '\x2', '\x2', '\x692', + '\x693', '\a', '\x46', '\x2', '\x2', '\x693', '\x694', '\x5', '\x1AE', + '\xD8', '\x2', '\x694', '\x695', '\a', 'G', '\x2', '\x2', '\x695', '\x696', + '\x5', '\x112', '\x8A', '\x2', '\x696', '\x123', '\x3', '\x2', '\x2', + '\x2', '\x697', '\x698', '\a', '\x19', '\x2', '\x2', '\x698', '\x699', + '\a', '\x46', '\x2', '\x2', '\x699', '\x69A', '\x5', '\x1AE', '\xD8', + '\x2', '\x69A', '\x69B', '\a', 'G', '\x2', '\x2', '\x69B', '\x69C', '\x5', + '\x114', '\x8B', '\x2', '\x69C', '\x69D', '\a', '\x11', '\x2', '\x2', + '\x69D', '\x69E', '\x5', '\x112', '\x8A', '\x2', '\x69E', '\x125', '\x3', + '\x2', '\x2', '\x2', '\x69F', '\x6A0', '\a', '\x19', '\x2', '\x2', '\x6A0', + '\x6A1', '\a', '\x46', '\x2', '\x2', '\x6A1', '\x6A2', '\x5', '\x1AE', + '\xD8', '\x2', '\x6A2', '\x6A3', '\a', 'G', '\x2', '\x2', '\x6A3', '\x6A4', + '\x5', '\x114', '\x8B', '\x2', '\x6A4', '\x6A5', '\a', '\x11', '\x2', + '\x2', '\x6A5', '\x6A6', '\x5', '\x114', '\x8B', '\x2', '\x6A6', '\x127', + '\x3', '\x2', '\x2', '\x2', '\x6A7', '\x6A8', '\a', '\x4', '\x2', '\x2', + '\x6A8', '\x6A9', '\x5', '\x1AE', '\xD8', '\x2', '\x6A9', '\x6AA', '\a', + 'L', '\x2', '\x2', '\x6AA', '\x6B2', '\x3', '\x2', '\x2', '\x2', '\x6AB', + '\x6AC', '\a', '\x4', '\x2', '\x2', '\x6AC', '\x6AD', '\x5', '\x1AE', + '\xD8', '\x2', '\x6AD', '\x6AE', '\a', 'X', '\x2', '\x2', '\x6AE', '\x6AF', + '\x5', '\x1AE', '\xD8', '\x2', '\x6AF', '\x6B0', '\a', 'L', '\x2', '\x2', + '\x6B0', '\x6B2', '\x3', '\x2', '\x2', '\x2', '\x6B1', '\x6A7', '\x3', + '\x2', '\x2', '\x2', '\x6B1', '\x6AB', '\x3', '\x2', '\x2', '\x2', '\x6B2', + '\x129', '\x3', '\x2', '\x2', '\x2', '\x6B3', '\x6B4', '\a', '\x31', '\x2', + '\x2', '\x6B4', '\x6B5', '\a', '\x46', '\x2', '\x2', '\x6B5', '\x6B6', + '\x5', '\x1AE', '\xD8', '\x2', '\x6B6', '\x6B7', '\a', 'G', '\x2', '\x2', + '\x6B7', '\x6B8', '\x5', '\x12C', '\x97', '\x2', '\x6B8', '\x12B', '\x3', + '\x2', '\x2', '\x2', '\x6B9', '\x6BD', '\a', 'H', '\x2', '\x2', '\x6BA', + '\x6BC', '\x5', '\x12E', '\x98', '\x2', '\x6BB', '\x6BA', '\x3', '\x2', + '\x2', '\x2', '\x6BC', '\x6BF', '\x3', '\x2', '\x2', '\x2', '\x6BD', '\x6BB', + '\x3', '\x2', '\x2', '\x2', '\x6BD', '\x6BE', '\x3', '\x2', '\x2', '\x2', + '\x6BE', '\x6C3', '\x3', '\x2', '\x2', '\x2', '\x6BF', '\x6BD', '\x3', + '\x2', '\x2', '\x2', '\x6C0', '\x6C2', '\x5', '\x132', '\x9A', '\x2', + '\x6C1', '\x6C0', '\x3', '\x2', '\x2', '\x2', '\x6C2', '\x6C5', '\x3', + '\x2', '\x2', '\x2', '\x6C3', '\x6C1', '\x3', '\x2', '\x2', '\x2', '\x6C3', + '\x6C4', '\x3', '\x2', '\x2', '\x2', '\x6C4', '\x6C6', '\x3', '\x2', '\x2', + '\x2', '\x6C5', '\x6C3', '\x3', '\x2', '\x2', '\x2', '\x6C6', '\x6C7', + '\a', 'I', '\x2', '\x2', '\x6C7', '\x12D', '\x3', '\x2', '\x2', '\x2', + '\x6C8', '\x6C9', '\x5', '\x130', '\x99', '\x2', '\x6C9', '\x6CA', '\x5', + '\x10A', '\x86', '\x2', '\x6CA', '\x12F', '\x3', '\x2', '\x2', '\x2', + '\x6CB', '\x6CD', '\x5', '\x132', '\x9A', '\x2', '\x6CC', '\x6CB', '\x3', + '\x2', '\x2', '\x2', '\x6CD', '\x6CE', '\x3', '\x2', '\x2', '\x2', '\x6CE', + '\x6CC', '\x3', '\x2', '\x2', '\x2', '\x6CE', '\x6CF', '\x3', '\x2', '\x2', + '\x2', '\x6CF', '\x131', '\x3', '\x2', '\x2', '\x2', '\x6D0', '\x6D1', + '\a', '\b', '\x2', '\x2', '\x6D1', '\x6D2', '\x5', '\x1AC', '\xD7', '\x2', + '\x6D2', '\x6D3', '\a', 'X', '\x2', '\x2', '\x6D3', '\x6DB', '\x3', '\x2', + '\x2', '\x2', '\x6D4', '\x6D5', '\a', '\b', '\x2', '\x2', '\x6D5', '\x6D6', + '\x5', '\x134', '\x9B', '\x2', '\x6D6', '\x6D7', '\a', 'X', '\x2', '\x2', + '\x6D7', '\x6DB', '\x3', '\x2', '\x2', '\x2', '\x6D8', '\x6D9', '\a', + '\xE', '\x2', '\x2', '\x6D9', '\x6DB', '\a', 'X', '\x2', '\x2', '\x6DA', + '\x6D0', '\x3', '\x2', '\x2', '\x2', '\x6DA', '\x6D4', '\x3', '\x2', '\x2', + '\x2', '\x6DA', '\x6D8', '\x3', '\x2', '\x2', '\x2', '\x6DB', '\x133', + '\x3', '\x2', '\x2', '\x2', '\x6DC', '\x6DD', '\x5', '\x1EA', '\xF6', + '\x2', '\x6DD', '\x135', '\x3', '\x2', '\x2', '\x2', '\x6DE', '\x6DF', + '\a', '=', '\x2', '\x2', '\x6DF', '\x6E0', '\a', '\x46', '\x2', '\x2', + '\x6E0', '\x6E1', '\x5', '\x1AE', '\xD8', '\x2', '\x6E1', '\x6E2', '\a', + 'G', '\x2', '\x2', '\x6E2', '\x6E3', '\x5', '\x112', '\x8A', '\x2', '\x6E3', + '\x137', '\x3', '\x2', '\x2', '\x2', '\x6E4', '\x6E5', '\a', '=', '\x2', + '\x2', '\x6E5', '\x6E6', '\a', '\x46', '\x2', '\x2', '\x6E6', '\x6E7', + '\x5', '\x1AE', '\xD8', '\x2', '\x6E7', '\x6E8', '\a', 'G', '\x2', '\x2', + '\x6E8', '\x6E9', '\x5', '\x114', '\x8B', '\x2', '\x6E9', '\x139', '\x3', + '\x2', '\x2', '\x2', '\x6EA', '\x6EB', '\a', '\xF', '\x2', '\x2', '\x6EB', + '\x6EC', '\x5', '\x112', '\x8A', '\x2', '\x6EC', '\x6ED', '\a', '=', '\x2', + '\x2', '\x6ED', '\x6EE', '\a', '\x46', '\x2', '\x2', '\x6EE', '\x6EF', + '\x5', '\x1AE', '\xD8', '\x2', '\x6EF', '\x6F0', '\a', 'G', '\x2', '\x2', + '\x6F0', '\x6F1', '\a', 'L', '\x2', '\x2', '\x6F1', '\x13B', '\x3', '\x2', + '\x2', '\x2', '\x6F2', '\x6F5', '\x5', '\x140', '\xA1', '\x2', '\x6F3', + '\x6F5', '\x5', '\x14A', '\xA6', '\x2', '\x6F4', '\x6F2', '\x3', '\x2', + '\x2', '\x2', '\x6F4', '\x6F3', '\x3', '\x2', '\x2', '\x2', '\x6F5', '\x13D', + '\x3', '\x2', '\x2', '\x2', '\x6F6', '\x6F9', '\x5', '\x142', '\xA2', + '\x2', '\x6F7', '\x6F9', '\x5', '\x14C', '\xA7', '\x2', '\x6F8', '\x6F6', + '\x3', '\x2', '\x2', '\x2', '\x6F8', '\x6F7', '\x3', '\x2', '\x2', '\x2', + '\x6F9', '\x13F', '\x3', '\x2', '\x2', '\x2', '\x6FA', '\x6FB', '\a', + '\x18', '\x2', '\x2', '\x6FB', '\x6FD', '\a', '\x46', '\x2', '\x2', '\x6FC', + '\x6FE', '\x5', '\x144', '\xA3', '\x2', '\x6FD', '\x6FC', '\x3', '\x2', + '\x2', '\x2', '\x6FD', '\x6FE', '\x3', '\x2', '\x2', '\x2', '\x6FE', '\x6FF', + '\x3', '\x2', '\x2', '\x2', '\x6FF', '\x701', '\a', 'L', '\x2', '\x2', + '\x700', '\x702', '\x5', '\x1AE', '\xD8', '\x2', '\x701', '\x700', '\x3', + '\x2', '\x2', '\x2', '\x701', '\x702', '\x3', '\x2', '\x2', '\x2', '\x702', + '\x703', '\x3', '\x2', '\x2', '\x2', '\x703', '\x705', '\a', 'L', '\x2', + '\x2', '\x704', '\x706', '\x5', '\x146', '\xA4', '\x2', '\x705', '\x704', + '\x3', '\x2', '\x2', '\x2', '\x705', '\x706', '\x3', '\x2', '\x2', '\x2', + '\x706', '\x707', '\x3', '\x2', '\x2', '\x2', '\x707', '\x708', '\a', + 'G', '\x2', '\x2', '\x708', '\x709', '\x5', '\x112', '\x8A', '\x2', '\x709', + '\x141', '\x3', '\x2', '\x2', '\x2', '\x70A', '\x70B', '\a', '\x18', '\x2', + '\x2', '\x70B', '\x70D', '\a', '\x46', '\x2', '\x2', '\x70C', '\x70E', + '\x5', '\x144', '\xA3', '\x2', '\x70D', '\x70C', '\x3', '\x2', '\x2', + '\x2', '\x70D', '\x70E', '\x3', '\x2', '\x2', '\x2', '\x70E', '\x70F', + '\x3', '\x2', '\x2', '\x2', '\x70F', '\x711', '\a', 'L', '\x2', '\x2', + '\x710', '\x712', '\x5', '\x1AE', '\xD8', '\x2', '\x711', '\x710', '\x3', + '\x2', '\x2', '\x2', '\x711', '\x712', '\x3', '\x2', '\x2', '\x2', '\x712', + '\x713', '\x3', '\x2', '\x2', '\x2', '\x713', '\x715', '\a', 'L', '\x2', + '\x2', '\x714', '\x716', '\x5', '\x146', '\xA4', '\x2', '\x715', '\x714', + '\x3', '\x2', '\x2', '\x2', '\x715', '\x716', '\x3', '\x2', '\x2', '\x2', + '\x716', '\x717', '\x3', '\x2', '\x2', '\x2', '\x717', '\x718', '\a', + 'G', '\x2', '\x2', '\x718', '\x719', '\x5', '\x114', '\x8B', '\x2', '\x719', + '\x143', '\x3', '\x2', '\x2', '\x2', '\x71A', '\x71D', '\x5', '\x148', + '\xA5', '\x2', '\x71B', '\x71D', '\x5', '\x110', '\x89', '\x2', '\x71C', + '\x71A', '\x3', '\x2', '\x2', '\x2', '\x71C', '\x71B', '\x3', '\x2', '\x2', + '\x2', '\x71D', '\x145', '\x3', '\x2', '\x2', '\x2', '\x71E', '\x71F', + '\x5', '\x148', '\xA5', '\x2', '\x71F', '\x147', '\x3', '\x2', '\x2', + '\x2', '\x720', '\x725', '\x5', '\x120', '\x91', '\x2', '\x721', '\x722', + '\a', 'M', '\x2', '\x2', '\x722', '\x724', '\x5', '\x120', '\x91', '\x2', + '\x723', '\x721', '\x3', '\x2', '\x2', '\x2', '\x724', '\x727', '\x3', + '\x2', '\x2', '\x2', '\x725', '\x723', '\x3', '\x2', '\x2', '\x2', '\x725', + '\x726', '\x3', '\x2', '\x2', '\x2', '\x726', '\x149', '\x3', '\x2', '\x2', + '\x2', '\x727', '\x725', '\x3', '\x2', '\x2', '\x2', '\x728', '\x729', + '\a', '\x18', '\x2', '\x2', '\x729', '\x72D', '\a', '\x46', '\x2', '\x2', + '\x72A', '\x72C', '\x5', '\xA8', 'U', '\x2', '\x72B', '\x72A', '\x3', + '\x2', '\x2', '\x2', '\x72C', '\x72F', '\x3', '\x2', '\x2', '\x2', '\x72D', + '\x72B', '\x3', '\x2', '\x2', '\x2', '\x72D', '\x72E', '\x3', '\x2', '\x2', + '\x2', '\x72E', '\x730', '\x3', '\x2', '\x2', '\x2', '\x72F', '\x72D', + '\x3', '\x2', '\x2', '\x2', '\x730', '\x731', '\x5', '\x80', '\x41', '\x2', + '\x731', '\x732', '\x5', '|', '?', '\x2', '\x732', '\x733', '\a', 'X', + '\x2', '\x2', '\x733', '\x734', '\x5', '\x1AE', '\xD8', '\x2', '\x734', + '\x735', '\a', 'G', '\x2', '\x2', '\x735', '\x736', '\x5', '\x112', '\x8A', + '\x2', '\x736', '\x14B', '\x3', '\x2', '\x2', '\x2', '\x737', '\x738', + '\a', '\x18', '\x2', '\x2', '\x738', '\x73C', '\a', '\x46', '\x2', '\x2', + '\x739', '\x73B', '\x5', '\xA8', 'U', '\x2', '\x73A', '\x739', '\x3', + '\x2', '\x2', '\x2', '\x73B', '\x73E', '\x3', '\x2', '\x2', '\x2', '\x73C', + '\x73A', '\x3', '\x2', '\x2', '\x2', '\x73C', '\x73D', '\x3', '\x2', '\x2', + '\x2', '\x73D', '\x73F', '\x3', '\x2', '\x2', '\x2', '\x73E', '\x73C', + '\x3', '\x2', '\x2', '\x2', '\x73F', '\x740', '\x5', '\x80', '\x41', '\x2', + '\x740', '\x741', '\x5', '|', '?', '\x2', '\x741', '\x742', '\a', 'X', + '\x2', '\x2', '\x742', '\x743', '\x5', '\x1AE', '\xD8', '\x2', '\x743', + '\x744', '\a', 'G', '\x2', '\x2', '\x744', '\x745', '\x5', '\x114', '\x8B', + '\x2', '\x745', '\x14D', '\x3', '\x2', '\x2', '\x2', '\x746', '\x748', + '\a', '\x6', '\x2', '\x2', '\x747', '\x749', '\x5', '\x1EA', '\xF6', '\x2', + '\x748', '\x747', '\x3', '\x2', '\x2', '\x2', '\x748', '\x749', '\x3', + '\x2', '\x2', '\x2', '\x749', '\x74A', '\x3', '\x2', '\x2', '\x2', '\x74A', + '\x74B', '\a', 'L', '\x2', '\x2', '\x74B', '\x14F', '\x3', '\x2', '\x2', + '\x2', '\x74C', '\x74E', '\a', '\r', '\x2', '\x2', '\x74D', '\x74F', '\x5', + '\x1EA', '\xF6', '\x2', '\x74E', '\x74D', '\x3', '\x2', '\x2', '\x2', + '\x74E', '\x74F', '\x3', '\x2', '\x2', '\x2', '\x74F', '\x750', '\x3', + '\x2', '\x2', '\x2', '\x750', '\x751', '\a', 'L', '\x2', '\x2', '\x751', + '\x151', '\x3', '\x2', '\x2', '\x2', '\x752', '\x754', '\a', ',', '\x2', + '\x2', '\x753', '\x755', '\x5', '\x1AE', '\xD8', '\x2', '\x754', '\x753', + '\x3', '\x2', '\x2', '\x2', '\x754', '\x755', '\x3', '\x2', '\x2', '\x2', + '\x755', '\x756', '\x3', '\x2', '\x2', '\x2', '\x756', '\x757', '\a', + 'L', '\x2', '\x2', '\x757', '\x153', '\x3', '\x2', '\x2', '\x2', '\x758', + '\x759', '\a', '\x34', '\x2', '\x2', '\x759', '\x75A', '\x5', '\x1AE', + '\xD8', '\x2', '\x75A', '\x75B', '\a', 'L', '\x2', '\x2', '\x75B', '\x155', + '\x3', '\x2', '\x2', '\x2', '\x75C', '\x75D', '\a', '\x32', '\x2', '\x2', + '\x75D', '\x75E', '\a', '\x46', '\x2', '\x2', '\x75E', '\x75F', '\x5', + '\x1AE', '\xD8', '\x2', '\x75F', '\x760', '\a', 'G', '\x2', '\x2', '\x760', + '\x761', '\x5', '\x108', '\x85', '\x2', '\x761', '\x157', '\x3', '\x2', + '\x2', '\x2', '\x762', '\x763', '\a', '\x39', '\x2', '\x2', '\x763', '\x764', + '\x5', '\x108', '\x85', '\x2', '\x764', '\x765', '\x5', '\x15A', '\xAE', + '\x2', '\x765', '\x76F', '\x3', '\x2', '\x2', '\x2', '\x766', '\x767', + '\a', '\x39', '\x2', '\x2', '\x767', '\x769', '\x5', '\x108', '\x85', + '\x2', '\x768', '\x76A', '\x5', '\x15A', '\xAE', '\x2', '\x769', '\x768', + '\x3', '\x2', '\x2', '\x2', '\x769', '\x76A', '\x3', '\x2', '\x2', '\x2', + '\x76A', '\x76B', '\x3', '\x2', '\x2', '\x2', '\x76B', '\x76C', '\x5', + '\x162', '\xB2', '\x2', '\x76C', '\x76F', '\x3', '\x2', '\x2', '\x2', + '\x76D', '\x76F', '\x5', '\x164', '\xB3', '\x2', '\x76E', '\x762', '\x3', + '\x2', '\x2', '\x2', '\x76E', '\x766', '\x3', '\x2', '\x2', '\x2', '\x76E', + '\x76D', '\x3', '\x2', '\x2', '\x2', '\x76F', '\x159', '\x3', '\x2', '\x2', + '\x2', '\x770', '\x772', '\x5', '\x15C', '\xAF', '\x2', '\x771', '\x770', + '\x3', '\x2', '\x2', '\x2', '\x772', '\x773', '\x3', '\x2', '\x2', '\x2', + '\x773', '\x771', '\x3', '\x2', '\x2', '\x2', '\x773', '\x774', '\x3', + '\x2', '\x2', '\x2', '\x774', '\x15B', '\x3', '\x2', '\x2', '\x2', '\x775', + '\x776', '\a', '\t', '\x2', '\x2', '\x776', '\x777', '\a', '\x46', '\x2', + '\x2', '\x777', '\x778', '\x5', '\x15E', '\xB0', '\x2', '\x778', '\x779', + '\a', 'G', '\x2', '\x2', '\x779', '\x77A', '\x5', '\x108', '\x85', '\x2', + '\x77A', '\x15D', '\x3', '\x2', '\x2', '\x2', '\x77B', '\x77D', '\x5', + '\xA8', 'U', '\x2', '\x77C', '\x77B', '\x3', '\x2', '\x2', '\x2', '\x77D', + '\x780', '\x3', '\x2', '\x2', '\x2', '\x77E', '\x77C', '\x3', '\x2', '\x2', + '\x2', '\x77E', '\x77F', '\x3', '\x2', '\x2', '\x2', '\x77F', '\x781', + '\x3', '\x2', '\x2', '\x2', '\x780', '\x77E', '\x3', '\x2', '\x2', '\x2', + '\x781', '\x782', '\x5', '\x160', '\xB1', '\x2', '\x782', '\x783', '\x5', + '|', '?', '\x2', '\x783', '\x15F', '\x3', '\x2', '\x2', '\x2', '\x784', + '\x789', '\x5', '\x88', '\x45', '\x2', '\x785', '\x786', '\a', 'g', '\x2', + '\x2', '\x786', '\x788', '\x5', '\x10', '\t', '\x2', '\x787', '\x785', + '\x3', '\x2', '\x2', '\x2', '\x788', '\x78B', '\x3', '\x2', '\x2', '\x2', + '\x789', '\x787', '\x3', '\x2', '\x2', '\x2', '\x789', '\x78A', '\x3', + '\x2', '\x2', '\x2', '\x78A', '\x161', '\x3', '\x2', '\x2', '\x2', '\x78B', + '\x789', '\x3', '\x2', '\x2', '\x2', '\x78C', '\x78D', '\a', '\x16', '\x2', + '\x2', '\x78D', '\x78E', '\x5', '\x108', '\x85', '\x2', '\x78E', '\x163', + '\x3', '\x2', '\x2', '\x2', '\x78F', '\x790', '\a', '\x39', '\x2', '\x2', + '\x790', '\x791', '\x5', '\x166', '\xB4', '\x2', '\x791', '\x793', '\x5', + '\x108', '\x85', '\x2', '\x792', '\x794', '\x5', '\x15A', '\xAE', '\x2', + '\x793', '\x792', '\x3', '\x2', '\x2', '\x2', '\x793', '\x794', '\x3', + '\x2', '\x2', '\x2', '\x794', '\x796', '\x3', '\x2', '\x2', '\x2', '\x795', + '\x797', '\x5', '\x162', '\xB2', '\x2', '\x796', '\x795', '\x3', '\x2', + '\x2', '\x2', '\x796', '\x797', '\x3', '\x2', '\x2', '\x2', '\x797', '\x165', + '\x3', '\x2', '\x2', '\x2', '\x798', '\x799', '\a', '\x46', '\x2', '\x2', + '\x799', '\x79B', '\x5', '\x168', '\xB5', '\x2', '\x79A', '\x79C', '\a', + 'L', '\x2', '\x2', '\x79B', '\x79A', '\x3', '\x2', '\x2', '\x2', '\x79B', + '\x79C', '\x3', '\x2', '\x2', '\x2', '\x79C', '\x79D', '\x3', '\x2', '\x2', + '\x2', '\x79D', '\x79E', '\a', 'G', '\x2', '\x2', '\x79E', '\x167', '\x3', + '\x2', '\x2', '\x2', '\x79F', '\x7A4', '\x5', '\x16A', '\xB6', '\x2', + '\x7A0', '\x7A1', '\a', 'L', '\x2', '\x2', '\x7A1', '\x7A3', '\x5', '\x16A', + '\xB6', '\x2', '\x7A2', '\x7A0', '\x3', '\x2', '\x2', '\x2', '\x7A3', + '\x7A6', '\x3', '\x2', '\x2', '\x2', '\x7A4', '\x7A2', '\x3', '\x2', '\x2', + '\x2', '\x7A4', '\x7A5', '\x3', '\x2', '\x2', '\x2', '\x7A5', '\x169', + '\x3', '\x2', '\x2', '\x2', '\x7A6', '\x7A4', '\x3', '\x2', '\x2', '\x2', + '\x7A7', '\x7A9', '\x5', '\xA8', 'U', '\x2', '\x7A8', '\x7A7', '\x3', + '\x2', '\x2', '\x2', '\x7A9', '\x7AC', '\x3', '\x2', '\x2', '\x2', '\x7AA', + '\x7A8', '\x3', '\x2', '\x2', '\x2', '\x7AA', '\x7AB', '\x3', '\x2', '\x2', + '\x2', '\x7AB', '\x7AD', '\x3', '\x2', '\x2', '\x2', '\x7AC', '\x7AA', + '\x3', '\x2', '\x2', '\x2', '\x7AD', '\x7AE', '\x5', '\x80', '\x41', '\x2', + '\x7AE', '\x7AF', '\x5', '|', '?', '\x2', '\x7AF', '\x7B0', '\a', 'R', + '\x2', '\x2', '\x7B0', '\x7B1', '\x5', '\x1AE', '\xD8', '\x2', '\x7B1', + '\x7B4', '\x3', '\x2', '\x2', '\x2', '\x7B2', '\x7B4', '\x5', '\x16C', + '\xB7', '\x2', '\x7B3', '\x7AA', '\x3', '\x2', '\x2', '\x2', '\x7B3', + '\x7B2', '\x3', '\x2', '\x2', '\x2', '\x7B4', '\x16B', '\x3', '\x2', '\x2', + '\x2', '\x7B5', '\x7B8', '\x5', '<', '\x1F', '\x2', '\x7B6', '\x7B8', + '\x5', '\x18C', '\xC7', '\x2', '\x7B7', '\x7B5', '\x3', '\x2', '\x2', + '\x2', '\x7B7', '\x7B6', '\x3', '\x2', '\x2', '\x2', '\x7B8', '\x16D', + '\x3', '\x2', '\x2', '\x2', '\x7B9', '\x7BC', '\x5', '\x17C', '\xBF', + '\x2', '\x7BA', '\x7BC', '\x5', '\x1A6', '\xD4', '\x2', '\x7BB', '\x7B9', + '\x3', '\x2', '\x2', '\x2', '\x7BB', '\x7BA', '\x3', '\x2', '\x2', '\x2', + '\x7BC', '\x7C0', '\x3', '\x2', '\x2', '\x2', '\x7BD', '\x7BF', '\x5', + '\x176', '\xBC', '\x2', '\x7BE', '\x7BD', '\x3', '\x2', '\x2', '\x2', + '\x7BF', '\x7C2', '\x3', '\x2', '\x2', '\x2', '\x7C0', '\x7BE', '\x3', + '\x2', '\x2', '\x2', '\x7C0', '\x7C1', '\x3', '\x2', '\x2', '\x2', '\x7C1', + '\x16F', '\x3', '\x2', '\x2', '\x2', '\x7C2', '\x7C0', '\x3', '\x2', '\x2', + '\x2', '\x7C3', '\x7D4', '\x5', '\x2', '\x2', '\x2', '\x7C4', '\x7D4', + '\x5', '\x182', '\xC2', '\x2', '\x7C5', '\x7D4', '\a', '\x33', '\x2', + '\x2', '\x7C6', '\x7C7', '\x5', '\x38', '\x1D', '\x2', '\x7C7', '\x7C8', + '\a', 'N', '\x2', '\x2', '\x7C8', '\x7C9', '\a', '\x33', '\x2', '\x2', + '\x7C9', '\x7D4', '\x3', '\x2', '\x2', '\x2', '\x7CA', '\x7CB', '\a', + '\x46', '\x2', '\x2', '\x7CB', '\x7CC', '\x5', '\x1AE', '\xD8', '\x2', + '\x7CC', '\x7CD', '\a', 'G', '\x2', '\x2', '\x7CD', '\x7D4', '\x3', '\x2', + '\x2', '\x2', '\x7CE', '\x7D4', '\x5', '\x184', '\xC3', '\x2', '\x7CF', + '\x7D4', '\x5', '\x18C', '\xC7', '\x2', '\x7D0', '\x7D4', '\x5', '\x192', + '\xCA', '\x2', '\x7D1', '\x7D4', '\x5', '\x198', '\xCD', '\x2', '\x7D2', + '\x7D4', '\x5', '\x1A0', '\xD1', '\x2', '\x7D3', '\x7C3', '\x3', '\x2', + '\x2', '\x2', '\x7D3', '\x7C4', '\x3', '\x2', '\x2', '\x2', '\x7D3', '\x7C5', + '\x3', '\x2', '\x2', '\x2', '\x7D3', '\x7C6', '\x3', '\x2', '\x2', '\x2', + '\x7D3', '\x7CA', '\x3', '\x2', '\x2', '\x2', '\x7D3', '\x7CE', '\x3', + '\x2', '\x2', '\x2', '\x7D3', '\x7CF', '\x3', '\x2', '\x2', '\x2', '\x7D3', + '\x7D0', '\x3', '\x2', '\x2', '\x2', '\x7D3', '\x7D1', '\x3', '\x2', '\x2', + '\x2', '\x7D3', '\x7D2', '\x3', '\x2', '\x2', '\x2', '\x7D4', '\x171', + '\x3', '\x2', '\x2', '\x2', '\x7D5', '\x7D6', '\x3', '\x2', '\x2', '\x2', + '\x7D6', '\x173', '\x3', '\x2', '\x2', '\x2', '\x7D7', '\x7F4', '\x5', + '\x2', '\x2', '\x2', '\x7D8', '\x7DD', '\x5', '\x38', '\x1D', '\x2', '\x7D9', + '\x7DA', '\a', 'J', '\x2', '\x2', '\x7DA', '\x7DC', '\a', 'K', '\x2', + '\x2', '\x7DB', '\x7D9', '\x3', '\x2', '\x2', '\x2', '\x7DC', '\x7DF', + '\x3', '\x2', '\x2', '\x2', '\x7DD', '\x7DB', '\x3', '\x2', '\x2', '\x2', + '\x7DD', '\x7DE', '\x3', '\x2', '\x2', '\x2', '\x7DE', '\x7E0', '\x3', + '\x2', '\x2', '\x2', '\x7DF', '\x7DD', '\x3', '\x2', '\x2', '\x2', '\x7E0', + '\x7E1', '\a', 'N', '\x2', '\x2', '\x7E1', '\x7E2', '\a', '\v', '\x2', + '\x2', '\x7E2', '\x7F4', '\x3', '\x2', '\x2', '\x2', '\x7E3', '\x7E4', + '\a', ';', '\x2', '\x2', '\x7E4', '\x7E5', '\a', 'N', '\x2', '\x2', '\x7E5', + '\x7F4', '\a', '\v', '\x2', '\x2', '\x7E6', '\x7F4', '\a', '\x33', '\x2', + '\x2', '\x7E7', '\x7E8', '\x5', '\x38', '\x1D', '\x2', '\x7E8', '\x7E9', + '\a', 'N', '\x2', '\x2', '\x7E9', '\x7EA', '\a', '\x33', '\x2', '\x2', + '\x7EA', '\x7F4', '\x3', '\x2', '\x2', '\x2', '\x7EB', '\x7EC', '\a', + '\x46', '\x2', '\x2', '\x7EC', '\x7ED', '\x5', '\x1AE', '\xD8', '\x2', + '\x7ED', '\x7EE', '\a', 'G', '\x2', '\x2', '\x7EE', '\x7F4', '\x3', '\x2', + '\x2', '\x2', '\x7EF', '\x7F4', '\x5', '\x184', '\xC3', '\x2', '\x7F0', + '\x7F4', '\x5', '\x18C', '\xC7', '\x2', '\x7F1', '\x7F4', '\x5', '\x198', + '\xCD', '\x2', '\x7F2', '\x7F4', '\x5', '\x1A0', '\xD1', '\x2', '\x7F3', + '\x7D7', '\x3', '\x2', '\x2', '\x2', '\x7F3', '\x7D8', '\x3', '\x2', '\x2', + '\x2', '\x7F3', '\x7E3', '\x3', '\x2', '\x2', '\x2', '\x7F3', '\x7E6', + '\x3', '\x2', '\x2', '\x2', '\x7F3', '\x7E7', '\x3', '\x2', '\x2', '\x2', + '\x7F3', '\x7EB', '\x3', '\x2', '\x2', '\x2', '\x7F3', '\x7EF', '\x3', + '\x2', '\x2', '\x2', '\x7F3', '\x7F0', '\x3', '\x2', '\x2', '\x2', '\x7F3', + '\x7F1', '\x3', '\x2', '\x2', '\x2', '\x7F3', '\x7F2', '\x3', '\x2', '\x2', + '\x2', '\x7F4', '\x175', '\x3', '\x2', '\x2', '\x2', '\x7F5', '\x7FB', + '\x5', '\x186', '\xC4', '\x2', '\x7F6', '\x7FB', '\x5', '\x18E', '\xC8', + '\x2', '\x7F7', '\x7FB', '\x5', '\x194', '\xCB', '\x2', '\x7F8', '\x7FB', + '\x5', '\x19A', '\xCE', '\x2', '\x7F9', '\x7FB', '\x5', '\x1A2', '\xD2', + '\x2', '\x7FA', '\x7F5', '\x3', '\x2', '\x2', '\x2', '\x7FA', '\x7F6', + '\x3', '\x2', '\x2', '\x2', '\x7FA', '\x7F7', '\x3', '\x2', '\x2', '\x2', + '\x7FA', '\x7F8', '\x3', '\x2', '\x2', '\x2', '\x7FA', '\x7F9', '\x3', + '\x2', '\x2', '\x2', '\x7FB', '\x177', '\x3', '\x2', '\x2', '\x2', '\x7FC', + '\x7FD', '\x3', '\x2', '\x2', '\x2', '\x7FD', '\x179', '\x3', '\x2', '\x2', + '\x2', '\x7FE', '\x803', '\x5', '\x186', '\xC4', '\x2', '\x7FF', '\x803', + '\x5', '\x18E', '\xC8', '\x2', '\x800', '\x803', '\x5', '\x19A', '\xCE', + '\x2', '\x801', '\x803', '\x5', '\x1A2', '\xD2', '\x2', '\x802', '\x7FE', + '\x3', '\x2', '\x2', '\x2', '\x802', '\x7FF', '\x3', '\x2', '\x2', '\x2', + '\x802', '\x800', '\x3', '\x2', '\x2', '\x2', '\x802', '\x801', '\x3', + '\x2', '\x2', '\x2', '\x803', '\x17B', '\x3', '\x2', '\x2', '\x2', '\x804', + '\x82D', '\x5', '\x2', '\x2', '\x2', '\x805', '\x80A', '\x5', '\x38', + '\x1D', '\x2', '\x806', '\x807', '\a', 'J', '\x2', '\x2', '\x807', '\x809', + '\a', 'K', '\x2', '\x2', '\x808', '\x806', '\x3', '\x2', '\x2', '\x2', + '\x809', '\x80C', '\x3', '\x2', '\x2', '\x2', '\x80A', '\x808', '\x3', + '\x2', '\x2', '\x2', '\x80A', '\x80B', '\x3', '\x2', '\x2', '\x2', '\x80B', + '\x80D', '\x3', '\x2', '\x2', '\x2', '\x80C', '\x80A', '\x3', '\x2', '\x2', + '\x2', '\x80D', '\x80E', '\a', 'N', '\x2', '\x2', '\x80E', '\x80F', '\a', + '\v', '\x2', '\x2', '\x80F', '\x82D', '\x3', '\x2', '\x2', '\x2', '\x810', + '\x815', '\x5', '\x82', '\x42', '\x2', '\x811', '\x812', '\a', 'J', '\x2', + '\x2', '\x812', '\x814', '\a', 'K', '\x2', '\x2', '\x813', '\x811', '\x3', + '\x2', '\x2', '\x2', '\x814', '\x817', '\x3', '\x2', '\x2', '\x2', '\x815', + '\x813', '\x3', '\x2', '\x2', '\x2', '\x815', '\x816', '\x3', '\x2', '\x2', + '\x2', '\x816', '\x818', '\x3', '\x2', '\x2', '\x2', '\x817', '\x815', + '\x3', '\x2', '\x2', '\x2', '\x818', '\x819', '\a', 'N', '\x2', '\x2', + '\x819', '\x81A', '\a', '\v', '\x2', '\x2', '\x81A', '\x82D', '\x3', '\x2', + '\x2', '\x2', '\x81B', '\x81C', '\a', ';', '\x2', '\x2', '\x81C', '\x81D', + '\a', 'N', '\x2', '\x2', '\x81D', '\x82D', '\a', '\v', '\x2', '\x2', '\x81E', + '\x82D', '\a', '\x33', '\x2', '\x2', '\x81F', '\x820', '\x5', '\x38', + '\x1D', '\x2', '\x820', '\x821', '\a', 'N', '\x2', '\x2', '\x821', '\x822', + '\a', '\x33', '\x2', '\x2', '\x822', '\x82D', '\x3', '\x2', '\x2', '\x2', + '\x823', '\x824', '\a', '\x46', '\x2', '\x2', '\x824', '\x825', '\x5', + '\x1AE', '\xD8', '\x2', '\x825', '\x826', '\a', 'G', '\x2', '\x2', '\x826', + '\x82D', '\x3', '\x2', '\x2', '\x2', '\x827', '\x82D', '\x5', '\x188', + '\xC5', '\x2', '\x828', '\x82D', '\x5', '\x190', '\xC9', '\x2', '\x829', + '\x82D', '\x5', '\x196', '\xCC', '\x2', '\x82A', '\x82D', '\x5', '\x19C', + '\xCF', '\x2', '\x82B', '\x82D', '\x5', '\x1A4', '\xD3', '\x2', '\x82C', + '\x804', '\x3', '\x2', '\x2', '\x2', '\x82C', '\x805', '\x3', '\x2', '\x2', + '\x2', '\x82C', '\x810', '\x3', '\x2', '\x2', '\x2', '\x82C', '\x81B', + '\x3', '\x2', '\x2', '\x2', '\x82C', '\x81E', '\x3', '\x2', '\x2', '\x2', + '\x82C', '\x81F', '\x3', '\x2', '\x2', '\x2', '\x82C', '\x823', '\x3', + '\x2', '\x2', '\x2', '\x82C', '\x827', '\x3', '\x2', '\x2', '\x2', '\x82C', + '\x828', '\x3', '\x2', '\x2', '\x2', '\x82C', '\x829', '\x3', '\x2', '\x2', + '\x2', '\x82C', '\x82A', '\x3', '\x2', '\x2', '\x2', '\x82C', '\x82B', + '\x3', '\x2', '\x2', '\x2', '\x82D', '\x17D', '\x3', '\x2', '\x2', '\x2', + '\x82E', '\x82F', '\x3', '\x2', '\x2', '\x2', '\x82F', '\x17F', '\x3', + '\x2', '\x2', '\x2', '\x830', '\x858', '\x5', '\x2', '\x2', '\x2', '\x831', + '\x836', '\x5', '\x38', '\x1D', '\x2', '\x832', '\x833', '\a', 'J', '\x2', + '\x2', '\x833', '\x835', '\a', 'K', '\x2', '\x2', '\x834', '\x832', '\x3', + '\x2', '\x2', '\x2', '\x835', '\x838', '\x3', '\x2', '\x2', '\x2', '\x836', + '\x834', '\x3', '\x2', '\x2', '\x2', '\x836', '\x837', '\x3', '\x2', '\x2', + '\x2', '\x837', '\x839', '\x3', '\x2', '\x2', '\x2', '\x838', '\x836', + '\x3', '\x2', '\x2', '\x2', '\x839', '\x83A', '\a', 'N', '\x2', '\x2', + '\x83A', '\x83B', '\a', '\v', '\x2', '\x2', '\x83B', '\x858', '\x3', '\x2', + '\x2', '\x2', '\x83C', '\x841', '\x5', '\x82', '\x42', '\x2', '\x83D', + '\x83E', '\a', 'J', '\x2', '\x2', '\x83E', '\x840', '\a', 'K', '\x2', + '\x2', '\x83F', '\x83D', '\x3', '\x2', '\x2', '\x2', '\x840', '\x843', + '\x3', '\x2', '\x2', '\x2', '\x841', '\x83F', '\x3', '\x2', '\x2', '\x2', + '\x841', '\x842', '\x3', '\x2', '\x2', '\x2', '\x842', '\x844', '\x3', + '\x2', '\x2', '\x2', '\x843', '\x841', '\x3', '\x2', '\x2', '\x2', '\x844', + '\x845', '\a', 'N', '\x2', '\x2', '\x845', '\x846', '\a', '\v', '\x2', + '\x2', '\x846', '\x858', '\x3', '\x2', '\x2', '\x2', '\x847', '\x848', + '\a', ';', '\x2', '\x2', '\x848', '\x849', '\a', 'N', '\x2', '\x2', '\x849', + '\x858', '\a', '\v', '\x2', '\x2', '\x84A', '\x858', '\a', '\x33', '\x2', + '\x2', '\x84B', '\x84C', '\x5', '\x38', '\x1D', '\x2', '\x84C', '\x84D', + '\a', 'N', '\x2', '\x2', '\x84D', '\x84E', '\a', '\x33', '\x2', '\x2', + '\x84E', '\x858', '\x3', '\x2', '\x2', '\x2', '\x84F', '\x850', '\a', + '\x46', '\x2', '\x2', '\x850', '\x851', '\x5', '\x1AE', '\xD8', '\x2', + '\x851', '\x852', '\a', 'G', '\x2', '\x2', '\x852', '\x858', '\x3', '\x2', + '\x2', '\x2', '\x853', '\x858', '\x5', '\x188', '\xC5', '\x2', '\x854', + '\x858', '\x5', '\x190', '\xC9', '\x2', '\x855', '\x858', '\x5', '\x19C', + '\xCF', '\x2', '\x856', '\x858', '\x5', '\x1A4', '\xD3', '\x2', '\x857', + '\x830', '\x3', '\x2', '\x2', '\x2', '\x857', '\x831', '\x3', '\x2', '\x2', + '\x2', '\x857', '\x83C', '\x3', '\x2', '\x2', '\x2', '\x857', '\x847', + '\x3', '\x2', '\x2', '\x2', '\x857', '\x84A', '\x3', '\x2', '\x2', '\x2', + '\x857', '\x84B', '\x3', '\x2', '\x2', '\x2', '\x857', '\x84F', '\x3', + '\x2', '\x2', '\x2', '\x857', '\x853', '\x3', '\x2', '\x2', '\x2', '\x857', + '\x854', '\x3', '\x2', '\x2', '\x2', '\x857', '\x855', '\x3', '\x2', '\x2', + '\x2', '\x857', '\x856', '\x3', '\x2', '\x2', '\x2', '\x858', '\x181', + '\x3', '\x2', '\x2', '\x2', '\x859', '\x85D', '\x5', '\x38', '\x1D', '\x2', + '\x85A', '\x85D', '\x5', '\x6', '\x4', '\x2', '\x85B', '\x85D', '\a', + '\x5', '\x2', '\x2', '\x85C', '\x859', '\x3', '\x2', '\x2', '\x2', '\x85C', + '\x85A', '\x3', '\x2', '\x2', '\x2', '\x85C', '\x85B', '\x3', '\x2', '\x2', + '\x2', '\x85D', '\x862', '\x3', '\x2', '\x2', '\x2', '\x85E', '\x85F', + '\a', 'J', '\x2', '\x2', '\x85F', '\x861', '\a', 'K', '\x2', '\x2', '\x860', + '\x85E', '\x3', '\x2', '\x2', '\x2', '\x861', '\x864', '\x3', '\x2', '\x2', + '\x2', '\x862', '\x860', '\x3', '\x2', '\x2', '\x2', '\x862', '\x863', + '\x3', '\x2', '\x2', '\x2', '\x863', '\x865', '\x3', '\x2', '\x2', '\x2', + '\x864', '\x862', '\x3', '\x2', '\x2', '\x2', '\x865', '\x866', '\a', + 'N', '\x2', '\x2', '\x866', '\x86B', '\a', '\v', '\x2', '\x2', '\x867', + '\x868', '\a', ';', '\x2', '\x2', '\x868', '\x869', '\a', 'N', '\x2', + '\x2', '\x869', '\x86B', '\a', '\v', '\x2', '\x2', '\x86A', '\x85C', '\x3', + '\x2', '\x2', '\x2', '\x86A', '\x867', '\x3', '\x2', '\x2', '\x2', '\x86B', + '\x183', '\x3', '\x2', '\x2', '\x2', '\x86C', '\x86E', '\a', '#', '\x2', + '\x2', '\x86D', '\x86F', '\x5', '*', '\x16', '\x2', '\x86E', '\x86D', + '\x3', '\x2', '\x2', '\x2', '\x86E', '\x86F', '\x3', '\x2', '\x2', '\x2', + '\x86F', '\x873', '\x3', '\x2', '\x2', '\x2', '\x870', '\x872', '\x5', + '\xF2', 'z', '\x2', '\x871', '\x870', '\x3', '\x2', '\x2', '\x2', '\x872', + '\x875', '\x3', '\x2', '\x2', '\x2', '\x873', '\x871', '\x3', '\x2', '\x2', + '\x2', '\x873', '\x874', '\x3', '\x2', '\x2', '\x2', '\x874', '\x876', + '\x3', '\x2', '\x2', '\x2', '\x875', '\x873', '\x3', '\x2', '\x2', '\x2', + '\x876', '\x881', '\x5', '\x1EA', '\xF6', '\x2', '\x877', '\x87B', '\a', + 'N', '\x2', '\x2', '\x878', '\x87A', '\x5', '\xF2', 'z', '\x2', '\x879', + '\x878', '\x3', '\x2', '\x2', '\x2', '\x87A', '\x87D', '\x3', '\x2', '\x2', + '\x2', '\x87B', '\x879', '\x3', '\x2', '\x2', '\x2', '\x87B', '\x87C', + '\x3', '\x2', '\x2', '\x2', '\x87C', '\x87E', '\x3', '\x2', '\x2', '\x2', + '\x87D', '\x87B', '\x3', '\x2', '\x2', '\x2', '\x87E', '\x880', '\x5', + '\x1EA', '\xF6', '\x2', '\x87F', '\x877', '\x3', '\x2', '\x2', '\x2', + '\x880', '\x883', '\x3', '\x2', '\x2', '\x2', '\x881', '\x87F', '\x3', + '\x2', '\x2', '\x2', '\x881', '\x882', '\x3', '\x2', '\x2', '\x2', '\x882', + '\x885', '\x3', '\x2', '\x2', '\x2', '\x883', '\x881', '\x3', '\x2', '\x2', + '\x2', '\x884', '\x886', '\x5', '\x18A', '\xC6', '\x2', '\x885', '\x884', + '\x3', '\x2', '\x2', '\x2', '\x885', '\x886', '\x3', '\x2', '\x2', '\x2', + '\x886', '\x887', '\x3', '\x2', '\x2', '\x2', '\x887', '\x889', '\a', + '\x46', '\x2', '\x2', '\x888', '\x88A', '\x5', '\x19E', '\xD0', '\x2', + '\x889', '\x888', '\x3', '\x2', '\x2', '\x2', '\x889', '\x88A', '\x3', + '\x2', '\x2', '\x2', '\x88A', '\x88B', '\x3', '\x2', '\x2', '\x2', '\x88B', + '\x88D', '\a', 'G', '\x2', '\x2', '\x88C', '\x88E', '\x5', 'n', '\x38', + '\x2', '\x88D', '\x88C', '\x3', '\x2', '\x2', '\x2', '\x88D', '\x88E', + '\x3', '\x2', '\x2', '\x2', '\x88E', '\x8C0', '\x3', '\x2', '\x2', '\x2', + '\x88F', '\x890', '\x5', '<', '\x1F', '\x2', '\x890', '\x891', '\a', 'N', + '\x2', '\x2', '\x891', '\x893', '\a', '#', '\x2', '\x2', '\x892', '\x894', + '\x5', '*', '\x16', '\x2', '\x893', '\x892', '\x3', '\x2', '\x2', '\x2', + '\x893', '\x894', '\x3', '\x2', '\x2', '\x2', '\x894', '\x898', '\x3', + '\x2', '\x2', '\x2', '\x895', '\x897', '\x5', '\xF2', 'z', '\x2', '\x896', + '\x895', '\x3', '\x2', '\x2', '\x2', '\x897', '\x89A', '\x3', '\x2', '\x2', + '\x2', '\x898', '\x896', '\x3', '\x2', '\x2', '\x2', '\x898', '\x899', + '\x3', '\x2', '\x2', '\x2', '\x899', '\x89B', '\x3', '\x2', '\x2', '\x2', + '\x89A', '\x898', '\x3', '\x2', '\x2', '\x2', '\x89B', '\x89D', '\x5', + '\x1EA', '\xF6', '\x2', '\x89C', '\x89E', '\x5', '\x18A', '\xC6', '\x2', + '\x89D', '\x89C', '\x3', '\x2', '\x2', '\x2', '\x89D', '\x89E', '\x3', + '\x2', '\x2', '\x2', '\x89E', '\x89F', '\x3', '\x2', '\x2', '\x2', '\x89F', + '\x8A1', '\a', '\x46', '\x2', '\x2', '\x8A0', '\x8A2', '\x5', '\x19E', + '\xD0', '\x2', '\x8A1', '\x8A0', '\x3', '\x2', '\x2', '\x2', '\x8A1', + '\x8A2', '\x3', '\x2', '\x2', '\x2', '\x8A2', '\x8A3', '\x3', '\x2', '\x2', + '\x2', '\x8A3', '\x8A5', '\a', 'G', '\x2', '\x2', '\x8A4', '\x8A6', '\x5', + 'n', '\x38', '\x2', '\x8A5', '\x8A4', '\x3', '\x2', '\x2', '\x2', '\x8A5', + '\x8A6', '\x3', '\x2', '\x2', '\x2', '\x8A6', '\x8C0', '\x3', '\x2', '\x2', + '\x2', '\x8A7', '\x8A8', '\x5', '\x16E', '\xB8', '\x2', '\x8A8', '\x8A9', + '\a', 'N', '\x2', '\x2', '\x8A9', '\x8AB', '\a', '#', '\x2', '\x2', '\x8AA', + '\x8AC', '\x5', '*', '\x16', '\x2', '\x8AB', '\x8AA', '\x3', '\x2', '\x2', + '\x2', '\x8AB', '\x8AC', '\x3', '\x2', '\x2', '\x2', '\x8AC', '\x8B0', + '\x3', '\x2', '\x2', '\x2', '\x8AD', '\x8AF', '\x5', '\xF2', 'z', '\x2', + '\x8AE', '\x8AD', '\x3', '\x2', '\x2', '\x2', '\x8AF', '\x8B2', '\x3', + '\x2', '\x2', '\x2', '\x8B0', '\x8AE', '\x3', '\x2', '\x2', '\x2', '\x8B0', + '\x8B1', '\x3', '\x2', '\x2', '\x2', '\x8B1', '\x8B3', '\x3', '\x2', '\x2', + '\x2', '\x8B2', '\x8B0', '\x3', '\x2', '\x2', '\x2', '\x8B3', '\x8B5', + '\x5', '\x1EA', '\xF6', '\x2', '\x8B4', '\x8B6', '\x5', '\x18A', '\xC6', + '\x2', '\x8B5', '\x8B4', '\x3', '\x2', '\x2', '\x2', '\x8B5', '\x8B6', + '\x3', '\x2', '\x2', '\x2', '\x8B6', '\x8B7', '\x3', '\x2', '\x2', '\x2', + '\x8B7', '\x8B9', '\a', '\x46', '\x2', '\x2', '\x8B8', '\x8BA', '\x5', + '\x19E', '\xD0', '\x2', '\x8B9', '\x8B8', '\x3', '\x2', '\x2', '\x2', + '\x8B9', '\x8BA', '\x3', '\x2', '\x2', '\x2', '\x8BA', '\x8BB', '\x3', + '\x2', '\x2', '\x2', '\x8BB', '\x8BD', '\a', 'G', '\x2', '\x2', '\x8BC', + '\x8BE', '\x5', 'n', '\x38', '\x2', '\x8BD', '\x8BC', '\x3', '\x2', '\x2', + '\x2', '\x8BD', '\x8BE', '\x3', '\x2', '\x2', '\x2', '\x8BE', '\x8C0', + '\x3', '\x2', '\x2', '\x2', '\x8BF', '\x86C', '\x3', '\x2', '\x2', '\x2', + '\x8BF', '\x88F', '\x3', '\x2', '\x2', '\x2', '\x8BF', '\x8A7', '\x3', + '\x2', '\x2', '\x2', '\x8C0', '\x185', '\x3', '\x2', '\x2', '\x2', '\x8C1', + '\x8C2', '\a', 'N', '\x2', '\x2', '\x8C2', '\x8C4', '\a', '#', '\x2', + '\x2', '\x8C3', '\x8C5', '\x5', '*', '\x16', '\x2', '\x8C4', '\x8C3', + '\x3', '\x2', '\x2', '\x2', '\x8C4', '\x8C5', '\x3', '\x2', '\x2', '\x2', + '\x8C5', '\x8C9', '\x3', '\x2', '\x2', '\x2', '\x8C6', '\x8C8', '\x5', + '\xF2', 'z', '\x2', '\x8C7', '\x8C6', '\x3', '\x2', '\x2', '\x2', '\x8C8', + '\x8CB', '\x3', '\x2', '\x2', '\x2', '\x8C9', '\x8C7', '\x3', '\x2', '\x2', + '\x2', '\x8C9', '\x8CA', '\x3', '\x2', '\x2', '\x2', '\x8CA', '\x8CC', + '\x3', '\x2', '\x2', '\x2', '\x8CB', '\x8C9', '\x3', '\x2', '\x2', '\x2', + '\x8CC', '\x8CE', '\x5', '\x1EA', '\xF6', '\x2', '\x8CD', '\x8CF', '\x5', + '\x18A', '\xC6', '\x2', '\x8CE', '\x8CD', '\x3', '\x2', '\x2', '\x2', + '\x8CE', '\x8CF', '\x3', '\x2', '\x2', '\x2', '\x8CF', '\x8D0', '\x3', + '\x2', '\x2', '\x2', '\x8D0', '\x8D2', '\a', '\x46', '\x2', '\x2', '\x8D1', + '\x8D3', '\x5', '\x19E', '\xD0', '\x2', '\x8D2', '\x8D1', '\x3', '\x2', + '\x2', '\x2', '\x8D2', '\x8D3', '\x3', '\x2', '\x2', '\x2', '\x8D3', '\x8D4', + '\x3', '\x2', '\x2', '\x2', '\x8D4', '\x8D6', '\a', 'G', '\x2', '\x2', + '\x8D5', '\x8D7', '\x5', 'n', '\x38', '\x2', '\x8D6', '\x8D5', '\x3', + '\x2', '\x2', '\x2', '\x8D6', '\x8D7', '\x3', '\x2', '\x2', '\x2', '\x8D7', + '\x187', '\x3', '\x2', '\x2', '\x2', '\x8D8', '\x8DA', '\a', '#', '\x2', + '\x2', '\x8D9', '\x8DB', '\x5', '*', '\x16', '\x2', '\x8DA', '\x8D9', + '\x3', '\x2', '\x2', '\x2', '\x8DA', '\x8DB', '\x3', '\x2', '\x2', '\x2', + '\x8DB', '\x8DF', '\x3', '\x2', '\x2', '\x2', '\x8DC', '\x8DE', '\x5', + '\xF2', 'z', '\x2', '\x8DD', '\x8DC', '\x3', '\x2', '\x2', '\x2', '\x8DE', + '\x8E1', '\x3', '\x2', '\x2', '\x2', '\x8DF', '\x8DD', '\x3', '\x2', '\x2', + '\x2', '\x8DF', '\x8E0', '\x3', '\x2', '\x2', '\x2', '\x8E0', '\x8E2', + '\x3', '\x2', '\x2', '\x2', '\x8E1', '\x8DF', '\x3', '\x2', '\x2', '\x2', + '\x8E2', '\x8ED', '\x5', '\x1EA', '\xF6', '\x2', '\x8E3', '\x8E7', '\a', + 'N', '\x2', '\x2', '\x8E4', '\x8E6', '\x5', '\xF2', 'z', '\x2', '\x8E5', + '\x8E4', '\x3', '\x2', '\x2', '\x2', '\x8E6', '\x8E9', '\x3', '\x2', '\x2', + '\x2', '\x8E7', '\x8E5', '\x3', '\x2', '\x2', '\x2', '\x8E7', '\x8E8', + '\x3', '\x2', '\x2', '\x2', '\x8E8', '\x8EA', '\x3', '\x2', '\x2', '\x2', + '\x8E9', '\x8E7', '\x3', '\x2', '\x2', '\x2', '\x8EA', '\x8EC', '\x5', + '\x1EA', '\xF6', '\x2', '\x8EB', '\x8E3', '\x3', '\x2', '\x2', '\x2', + '\x8EC', '\x8EF', '\x3', '\x2', '\x2', '\x2', '\x8ED', '\x8EB', '\x3', + '\x2', '\x2', '\x2', '\x8ED', '\x8EE', '\x3', '\x2', '\x2', '\x2', '\x8EE', + '\x8F1', '\x3', '\x2', '\x2', '\x2', '\x8EF', '\x8ED', '\x3', '\x2', '\x2', + '\x2', '\x8F0', '\x8F2', '\x5', '\x18A', '\xC6', '\x2', '\x8F1', '\x8F0', + '\x3', '\x2', '\x2', '\x2', '\x8F1', '\x8F2', '\x3', '\x2', '\x2', '\x2', + '\x8F2', '\x8F3', '\x3', '\x2', '\x2', '\x2', '\x8F3', '\x8F5', '\a', + '\x46', '\x2', '\x2', '\x8F4', '\x8F6', '\x5', '\x19E', '\xD0', '\x2', + '\x8F5', '\x8F4', '\x3', '\x2', '\x2', '\x2', '\x8F5', '\x8F6', '\x3', + '\x2', '\x2', '\x2', '\x8F6', '\x8F7', '\x3', '\x2', '\x2', '\x2', '\x8F7', + '\x8F9', '\a', 'G', '\x2', '\x2', '\x8F8', '\x8FA', '\x5', 'n', '\x38', + '\x2', '\x8F9', '\x8F8', '\x3', '\x2', '\x2', '\x2', '\x8F9', '\x8FA', + '\x3', '\x2', '\x2', '\x2', '\x8FA', '\x914', '\x3', '\x2', '\x2', '\x2', + '\x8FB', '\x8FC', '\x5', '<', '\x1F', '\x2', '\x8FC', '\x8FD', '\a', 'N', + '\x2', '\x2', '\x8FD', '\x8FF', '\a', '#', '\x2', '\x2', '\x8FE', '\x900', + '\x5', '*', '\x16', '\x2', '\x8FF', '\x8FE', '\x3', '\x2', '\x2', '\x2', + '\x8FF', '\x900', '\x3', '\x2', '\x2', '\x2', '\x900', '\x904', '\x3', + '\x2', '\x2', '\x2', '\x901', '\x903', '\x5', '\xF2', 'z', '\x2', '\x902', + '\x901', '\x3', '\x2', '\x2', '\x2', '\x903', '\x906', '\x3', '\x2', '\x2', + '\x2', '\x904', '\x902', '\x3', '\x2', '\x2', '\x2', '\x904', '\x905', + '\x3', '\x2', '\x2', '\x2', '\x905', '\x907', '\x3', '\x2', '\x2', '\x2', + '\x906', '\x904', '\x3', '\x2', '\x2', '\x2', '\x907', '\x909', '\x5', + '\x1EA', '\xF6', '\x2', '\x908', '\x90A', '\x5', '\x18A', '\xC6', '\x2', + '\x909', '\x908', '\x3', '\x2', '\x2', '\x2', '\x909', '\x90A', '\x3', + '\x2', '\x2', '\x2', '\x90A', '\x90B', '\x3', '\x2', '\x2', '\x2', '\x90B', + '\x90D', '\a', '\x46', '\x2', '\x2', '\x90C', '\x90E', '\x5', '\x19E', + '\xD0', '\x2', '\x90D', '\x90C', '\x3', '\x2', '\x2', '\x2', '\x90D', + '\x90E', '\x3', '\x2', '\x2', '\x2', '\x90E', '\x90F', '\x3', '\x2', '\x2', + '\x2', '\x90F', '\x911', '\a', 'G', '\x2', '\x2', '\x910', '\x912', '\x5', + 'n', '\x38', '\x2', '\x911', '\x910', '\x3', '\x2', '\x2', '\x2', '\x911', + '\x912', '\x3', '\x2', '\x2', '\x2', '\x912', '\x914', '\x3', '\x2', '\x2', + '\x2', '\x913', '\x8D8', '\x3', '\x2', '\x2', '\x2', '\x913', '\x8FB', + '\x3', '\x2', '\x2', '\x2', '\x914', '\x189', '\x3', '\x2', '\x2', '\x2', + '\x915', '\x919', '\x5', '*', '\x16', '\x2', '\x916', '\x917', '\a', 'T', + '\x2', '\x2', '\x917', '\x919', '\a', 'S', '\x2', '\x2', '\x918', '\x915', + '\x3', '\x2', '\x2', '\x2', '\x918', '\x916', '\x3', '\x2', '\x2', '\x2', + '\x919', '\x18B', '\x3', '\x2', '\x2', '\x2', '\x91A', '\x91B', '\x5', + '\x16E', '\xB8', '\x2', '\x91B', '\x91C', '\a', 'N', '\x2', '\x2', '\x91C', + '\x91D', '\x5', '\x1EA', '\xF6', '\x2', '\x91D', '\x928', '\x3', '\x2', + '\x2', '\x2', '\x91E', '\x91F', '\a', '\x30', '\x2', '\x2', '\x91F', '\x920', + '\a', 'N', '\x2', '\x2', '\x920', '\x928', '\x5', '\x1EA', '\xF6', '\x2', + '\x921', '\x922', '\x5', '\x38', '\x1D', '\x2', '\x922', '\x923', '\a', + 'N', '\x2', '\x2', '\x923', '\x924', '\a', '\x30', '\x2', '\x2', '\x924', + '\x925', '\a', 'N', '\x2', '\x2', '\x925', '\x926', '\x5', '\x1EA', '\xF6', + '\x2', '\x926', '\x928', '\x3', '\x2', '\x2', '\x2', '\x927', '\x91A', + '\x3', '\x2', '\x2', '\x2', '\x927', '\x91E', '\x3', '\x2', '\x2', '\x2', + '\x927', '\x921', '\x3', '\x2', '\x2', '\x2', '\x928', '\x18D', '\x3', + '\x2', '\x2', '\x2', '\x929', '\x92A', '\a', 'N', '\x2', '\x2', '\x92A', + '\x92B', '\x5', '\x1EA', '\xF6', '\x2', '\x92B', '\x18F', '\x3', '\x2', + '\x2', '\x2', '\x92C', '\x92D', '\a', '\x30', '\x2', '\x2', '\x92D', '\x92E', + '\a', 'N', '\x2', '\x2', '\x92E', '\x936', '\x5', '\x1EA', '\xF6', '\x2', + '\x92F', '\x930', '\x5', '\x38', '\x1D', '\x2', '\x930', '\x931', '\a', + 'N', '\x2', '\x2', '\x931', '\x932', '\a', '\x30', '\x2', '\x2', '\x932', + '\x933', '\a', 'N', '\x2', '\x2', '\x933', '\x934', '\x5', '\x1EA', '\xF6', + '\x2', '\x934', '\x936', '\x3', '\x2', '\x2', '\x2', '\x935', '\x92C', + '\x3', '\x2', '\x2', '\x2', '\x935', '\x92F', '\x3', '\x2', '\x2', '\x2', + '\x936', '\x191', '\x3', '\x2', '\x2', '\x2', '\x937', '\x938', '\x5', + '<', '\x1F', '\x2', '\x938', '\x939', '\a', 'J', '\x2', '\x2', '\x939', + '\x93A', '\x5', '\x1AE', '\xD8', '\x2', '\x93A', '\x93B', '\a', 'K', '\x2', + '\x2', '\x93B', '\x942', '\x3', '\x2', '\x2', '\x2', '\x93C', '\x93D', + '\x5', '\x174', '\xBB', '\x2', '\x93D', '\x93E', '\a', 'J', '\x2', '\x2', + '\x93E', '\x93F', '\x5', '\x1AE', '\xD8', '\x2', '\x93F', '\x940', '\a', + 'K', '\x2', '\x2', '\x940', '\x942', '\x3', '\x2', '\x2', '\x2', '\x941', + '\x937', '\x3', '\x2', '\x2', '\x2', '\x941', '\x93C', '\x3', '\x2', '\x2', + '\x2', '\x942', '\x94A', '\x3', '\x2', '\x2', '\x2', '\x943', '\x944', + '\x5', '\x172', '\xBA', '\x2', '\x944', '\x945', '\a', 'J', '\x2', '\x2', + '\x945', '\x946', '\x5', '\x1AE', '\xD8', '\x2', '\x946', '\x947', '\a', + 'K', '\x2', '\x2', '\x947', '\x949', '\x3', '\x2', '\x2', '\x2', '\x948', + '\x943', '\x3', '\x2', '\x2', '\x2', '\x949', '\x94C', '\x3', '\x2', '\x2', + '\x2', '\x94A', '\x948', '\x3', '\x2', '\x2', '\x2', '\x94A', '\x94B', + '\x3', '\x2', '\x2', '\x2', '\x94B', '\x193', '\x3', '\x2', '\x2', '\x2', + '\x94C', '\x94A', '\x3', '\x2', '\x2', '\x2', '\x94D', '\x94E', '\x5', + '\x17A', '\xBE', '\x2', '\x94E', '\x94F', '\a', 'J', '\x2', '\x2', '\x94F', + '\x950', '\x5', '\x1AE', '\xD8', '\x2', '\x950', '\x951', '\a', 'K', '\x2', + '\x2', '\x951', '\x959', '\x3', '\x2', '\x2', '\x2', '\x952', '\x953', + '\x5', '\x178', '\xBD', '\x2', '\x953', '\x954', '\a', 'J', '\x2', '\x2', + '\x954', '\x955', '\x5', '\x1AE', '\xD8', '\x2', '\x955', '\x956', '\a', + 'K', '\x2', '\x2', '\x956', '\x958', '\x3', '\x2', '\x2', '\x2', '\x957', + '\x952', '\x3', '\x2', '\x2', '\x2', '\x958', '\x95B', '\x3', '\x2', '\x2', + '\x2', '\x959', '\x957', '\x3', '\x2', '\x2', '\x2', '\x959', '\x95A', + '\x3', '\x2', '\x2', '\x2', '\x95A', '\x195', '\x3', '\x2', '\x2', '\x2', + '\x95B', '\x959', '\x3', '\x2', '\x2', '\x2', '\x95C', '\x95D', '\x5', + '<', '\x1F', '\x2', '\x95D', '\x95E', '\a', 'J', '\x2', '\x2', '\x95E', + '\x95F', '\x5', '\x1AE', '\xD8', '\x2', '\x95F', '\x960', '\a', 'K', '\x2', + '\x2', '\x960', '\x967', '\x3', '\x2', '\x2', '\x2', '\x961', '\x962', + '\x5', '\x180', '\xC1', '\x2', '\x962', '\x963', '\a', 'J', '\x2', '\x2', + '\x963', '\x964', '\x5', '\x1AE', '\xD8', '\x2', '\x964', '\x965', '\a', + 'K', '\x2', '\x2', '\x965', '\x967', '\x3', '\x2', '\x2', '\x2', '\x966', + '\x95C', '\x3', '\x2', '\x2', '\x2', '\x966', '\x961', '\x3', '\x2', '\x2', + '\x2', '\x967', '\x96F', '\x3', '\x2', '\x2', '\x2', '\x968', '\x969', + '\x5', '\x17E', '\xC0', '\x2', '\x969', '\x96A', '\a', 'J', '\x2', '\x2', + '\x96A', '\x96B', '\x5', '\x1AE', '\xD8', '\x2', '\x96B', '\x96C', '\a', + 'K', '\x2', '\x2', '\x96C', '\x96E', '\x3', '\x2', '\x2', '\x2', '\x96D', + '\x968', '\x3', '\x2', '\x2', '\x2', '\x96E', '\x971', '\x3', '\x2', '\x2', + '\x2', '\x96F', '\x96D', '\x3', '\x2', '\x2', '\x2', '\x96F', '\x970', + '\x3', '\x2', '\x2', '\x2', '\x970', '\x197', '\x3', '\x2', '\x2', '\x2', + '\x971', '\x96F', '\x3', '\x2', '\x2', '\x2', '\x972', '\x973', '\x5', + '>', ' ', '\x2', '\x973', '\x975', '\a', '\x46', '\x2', '\x2', '\x974', + '\x976', '\x5', '\x19E', '\xD0', '\x2', '\x975', '\x974', '\x3', '\x2', + '\x2', '\x2', '\x975', '\x976', '\x3', '\x2', '\x2', '\x2', '\x976', '\x977', + '\x3', '\x2', '\x2', '\x2', '\x977', '\x978', '\a', 'G', '\x2', '\x2', + '\x978', '\x9B8', '\x3', '\x2', '\x2', '\x2', '\x979', '\x97A', '\x5', + '\x38', '\x1D', '\x2', '\x97A', '\x97C', '\a', 'N', '\x2', '\x2', '\x97B', + '\x97D', '\x5', '*', '\x16', '\x2', '\x97C', '\x97B', '\x3', '\x2', '\x2', + '\x2', '\x97C', '\x97D', '\x3', '\x2', '\x2', '\x2', '\x97D', '\x97E', + '\x3', '\x2', '\x2', '\x2', '\x97E', '\x97F', '\x5', '\x1EA', '\xF6', + '\x2', '\x97F', '\x981', '\a', '\x46', '\x2', '\x2', '\x980', '\x982', + '\x5', '\x19E', '\xD0', '\x2', '\x981', '\x980', '\x3', '\x2', '\x2', + '\x2', '\x981', '\x982', '\x3', '\x2', '\x2', '\x2', '\x982', '\x983', + '\x3', '\x2', '\x2', '\x2', '\x983', '\x984', '\a', 'G', '\x2', '\x2', + '\x984', '\x9B8', '\x3', '\x2', '\x2', '\x2', '\x985', '\x986', '\x5', + '<', '\x1F', '\x2', '\x986', '\x988', '\a', 'N', '\x2', '\x2', '\x987', + '\x989', '\x5', '*', '\x16', '\x2', '\x988', '\x987', '\x3', '\x2', '\x2', + '\x2', '\x988', '\x989', '\x3', '\x2', '\x2', '\x2', '\x989', '\x98A', + '\x3', '\x2', '\x2', '\x2', '\x98A', '\x98B', '\x5', '\x1EA', '\xF6', + '\x2', '\x98B', '\x98D', '\a', '\x46', '\x2', '\x2', '\x98C', '\x98E', + '\x5', '\x19E', '\xD0', '\x2', '\x98D', '\x98C', '\x3', '\x2', '\x2', + '\x2', '\x98D', '\x98E', '\x3', '\x2', '\x2', '\x2', '\x98E', '\x98F', + '\x3', '\x2', '\x2', '\x2', '\x98F', '\x990', '\a', 'G', '\x2', '\x2', + '\x990', '\x9B8', '\x3', '\x2', '\x2', '\x2', '\x991', '\x992', '\x5', + '\x16E', '\xB8', '\x2', '\x992', '\x994', '\a', 'N', '\x2', '\x2', '\x993', + '\x995', '\x5', '*', '\x16', '\x2', '\x994', '\x993', '\x3', '\x2', '\x2', + '\x2', '\x994', '\x995', '\x3', '\x2', '\x2', '\x2', '\x995', '\x996', + '\x3', '\x2', '\x2', '\x2', '\x996', '\x997', '\x5', '\x1EA', '\xF6', + '\x2', '\x997', '\x999', '\a', '\x46', '\x2', '\x2', '\x998', '\x99A', + '\x5', '\x19E', '\xD0', '\x2', '\x999', '\x998', '\x3', '\x2', '\x2', + '\x2', '\x999', '\x99A', '\x3', '\x2', '\x2', '\x2', '\x99A', '\x99B', + '\x3', '\x2', '\x2', '\x2', '\x99B', '\x99C', '\a', 'G', '\x2', '\x2', + '\x99C', '\x9B8', '\x3', '\x2', '\x2', '\x2', '\x99D', '\x99E', '\a', + '\x30', '\x2', '\x2', '\x99E', '\x9A0', '\a', 'N', '\x2', '\x2', '\x99F', + '\x9A1', '\x5', '*', '\x16', '\x2', '\x9A0', '\x99F', '\x3', '\x2', '\x2', + '\x2', '\x9A0', '\x9A1', '\x3', '\x2', '\x2', '\x2', '\x9A1', '\x9A2', + '\x3', '\x2', '\x2', '\x2', '\x9A2', '\x9A3', '\x5', '\x1EA', '\xF6', + '\x2', '\x9A3', '\x9A5', '\a', '\x46', '\x2', '\x2', '\x9A4', '\x9A6', + '\x5', '\x19E', '\xD0', '\x2', '\x9A5', '\x9A4', '\x3', '\x2', '\x2', + '\x2', '\x9A5', '\x9A6', '\x3', '\x2', '\x2', '\x2', '\x9A6', '\x9A7', + '\x3', '\x2', '\x2', '\x2', '\x9A7', '\x9A8', '\a', 'G', '\x2', '\x2', + '\x9A8', '\x9B8', '\x3', '\x2', '\x2', '\x2', '\x9A9', '\x9AA', '\x5', + '\x38', '\x1D', '\x2', '\x9AA', '\x9AB', '\a', 'N', '\x2', '\x2', '\x9AB', + '\x9AC', '\a', '\x30', '\x2', '\x2', '\x9AC', '\x9AE', '\a', 'N', '\x2', + '\x2', '\x9AD', '\x9AF', '\x5', '*', '\x16', '\x2', '\x9AE', '\x9AD', + '\x3', '\x2', '\x2', '\x2', '\x9AE', '\x9AF', '\x3', '\x2', '\x2', '\x2', + '\x9AF', '\x9B0', '\x3', '\x2', '\x2', '\x2', '\x9B0', '\x9B1', '\x5', + '\x1EA', '\xF6', '\x2', '\x9B1', '\x9B3', '\a', '\x46', '\x2', '\x2', + '\x9B2', '\x9B4', '\x5', '\x19E', '\xD0', '\x2', '\x9B3', '\x9B2', '\x3', + '\x2', '\x2', '\x2', '\x9B3', '\x9B4', '\x3', '\x2', '\x2', '\x2', '\x9B4', + '\x9B5', '\x3', '\x2', '\x2', '\x2', '\x9B5', '\x9B6', '\a', 'G', '\x2', + '\x2', '\x9B6', '\x9B8', '\x3', '\x2', '\x2', '\x2', '\x9B7', '\x972', + '\x3', '\x2', '\x2', '\x2', '\x9B7', '\x979', '\x3', '\x2', '\x2', '\x2', + '\x9B7', '\x985', '\x3', '\x2', '\x2', '\x2', '\x9B7', '\x991', '\x3', + '\x2', '\x2', '\x2', '\x9B7', '\x99D', '\x3', '\x2', '\x2', '\x2', '\x9B7', + '\x9A9', '\x3', '\x2', '\x2', '\x2', '\x9B8', '\x199', '\x3', '\x2', '\x2', + '\x2', '\x9B9', '\x9BB', '\a', 'N', '\x2', '\x2', '\x9BA', '\x9BC', '\x5', + '*', '\x16', '\x2', '\x9BB', '\x9BA', '\x3', '\x2', '\x2', '\x2', '\x9BB', + '\x9BC', '\x3', '\x2', '\x2', '\x2', '\x9BC', '\x9BD', '\x3', '\x2', '\x2', + '\x2', '\x9BD', '\x9BE', '\x5', '\x1EA', '\xF6', '\x2', '\x9BE', '\x9C0', + '\a', '\x46', '\x2', '\x2', '\x9BF', '\x9C1', '\x5', '\x19E', '\xD0', + '\x2', '\x9C0', '\x9BF', '\x3', '\x2', '\x2', '\x2', '\x9C0', '\x9C1', + '\x3', '\x2', '\x2', '\x2', '\x9C1', '\x9C2', '\x3', '\x2', '\x2', '\x2', + '\x9C2', '\x9C3', '\a', 'G', '\x2', '\x2', '\x9C3', '\x19B', '\x3', '\x2', + '\x2', '\x2', '\x9C4', '\x9C5', '\x5', '>', ' ', '\x2', '\x9C5', '\x9C7', + '\a', '\x46', '\x2', '\x2', '\x9C6', '\x9C8', '\x5', '\x19E', '\xD0', + '\x2', '\x9C7', '\x9C6', '\x3', '\x2', '\x2', '\x2', '\x9C7', '\x9C8', + '\x3', '\x2', '\x2', '\x2', '\x9C8', '\x9C9', '\x3', '\x2', '\x2', '\x2', + '\x9C9', '\x9CA', '\a', 'G', '\x2', '\x2', '\x9CA', '\x9FE', '\x3', '\x2', + '\x2', '\x2', '\x9CB', '\x9CC', '\x5', '\x38', '\x1D', '\x2', '\x9CC', + '\x9CE', '\a', 'N', '\x2', '\x2', '\x9CD', '\x9CF', '\x5', '*', '\x16', + '\x2', '\x9CE', '\x9CD', '\x3', '\x2', '\x2', '\x2', '\x9CE', '\x9CF', + '\x3', '\x2', '\x2', '\x2', '\x9CF', '\x9D0', '\x3', '\x2', '\x2', '\x2', + '\x9D0', '\x9D1', '\x5', '\x1EA', '\xF6', '\x2', '\x9D1', '\x9D3', '\a', + '\x46', '\x2', '\x2', '\x9D2', '\x9D4', '\x5', '\x19E', '\xD0', '\x2', + '\x9D3', '\x9D2', '\x3', '\x2', '\x2', '\x2', '\x9D3', '\x9D4', '\x3', + '\x2', '\x2', '\x2', '\x9D4', '\x9D5', '\x3', '\x2', '\x2', '\x2', '\x9D5', + '\x9D6', '\a', 'G', '\x2', '\x2', '\x9D6', '\x9FE', '\x3', '\x2', '\x2', + '\x2', '\x9D7', '\x9D8', '\x5', '<', '\x1F', '\x2', '\x9D8', '\x9DA', + '\a', 'N', '\x2', '\x2', '\x9D9', '\x9DB', '\x5', '*', '\x16', '\x2', + '\x9DA', '\x9D9', '\x3', '\x2', '\x2', '\x2', '\x9DA', '\x9DB', '\x3', + '\x2', '\x2', '\x2', '\x9DB', '\x9DC', '\x3', '\x2', '\x2', '\x2', '\x9DC', + '\x9DD', '\x5', '\x1EA', '\xF6', '\x2', '\x9DD', '\x9DF', '\a', '\x46', + '\x2', '\x2', '\x9DE', '\x9E0', '\x5', '\x19E', '\xD0', '\x2', '\x9DF', + '\x9DE', '\x3', '\x2', '\x2', '\x2', '\x9DF', '\x9E0', '\x3', '\x2', '\x2', + '\x2', '\x9E0', '\x9E1', '\x3', '\x2', '\x2', '\x2', '\x9E1', '\x9E2', + '\a', 'G', '\x2', '\x2', '\x9E2', '\x9FE', '\x3', '\x2', '\x2', '\x2', + '\x9E3', '\x9E4', '\a', '\x30', '\x2', '\x2', '\x9E4', '\x9E6', '\a', + 'N', '\x2', '\x2', '\x9E5', '\x9E7', '\x5', '*', '\x16', '\x2', '\x9E6', + '\x9E5', '\x3', '\x2', '\x2', '\x2', '\x9E6', '\x9E7', '\x3', '\x2', '\x2', + '\x2', '\x9E7', '\x9E8', '\x3', '\x2', '\x2', '\x2', '\x9E8', '\x9E9', + '\x5', '\x1EA', '\xF6', '\x2', '\x9E9', '\x9EB', '\a', '\x46', '\x2', + '\x2', '\x9EA', '\x9EC', '\x5', '\x19E', '\xD0', '\x2', '\x9EB', '\x9EA', + '\x3', '\x2', '\x2', '\x2', '\x9EB', '\x9EC', '\x3', '\x2', '\x2', '\x2', + '\x9EC', '\x9ED', '\x3', '\x2', '\x2', '\x2', '\x9ED', '\x9EE', '\a', + 'G', '\x2', '\x2', '\x9EE', '\x9FE', '\x3', '\x2', '\x2', '\x2', '\x9EF', + '\x9F0', '\x5', '\x38', '\x1D', '\x2', '\x9F0', '\x9F1', '\a', 'N', '\x2', + '\x2', '\x9F1', '\x9F2', '\a', '\x30', '\x2', '\x2', '\x9F2', '\x9F4', + '\a', 'N', '\x2', '\x2', '\x9F3', '\x9F5', '\x5', '*', '\x16', '\x2', + '\x9F4', '\x9F3', '\x3', '\x2', '\x2', '\x2', '\x9F4', '\x9F5', '\x3', + '\x2', '\x2', '\x2', '\x9F5', '\x9F6', '\x3', '\x2', '\x2', '\x2', '\x9F6', + '\x9F7', '\x5', '\x1EA', '\xF6', '\x2', '\x9F7', '\x9F9', '\a', '\x46', + '\x2', '\x2', '\x9F8', '\x9FA', '\x5', '\x19E', '\xD0', '\x2', '\x9F9', + '\x9F8', '\x3', '\x2', '\x2', '\x2', '\x9F9', '\x9FA', '\x3', '\x2', '\x2', + '\x2', '\x9FA', '\x9FB', '\x3', '\x2', '\x2', '\x2', '\x9FB', '\x9FC', + '\a', 'G', '\x2', '\x2', '\x9FC', '\x9FE', '\x3', '\x2', '\x2', '\x2', + '\x9FD', '\x9C4', '\x3', '\x2', '\x2', '\x2', '\x9FD', '\x9CB', '\x3', + '\x2', '\x2', '\x2', '\x9FD', '\x9D7', '\x3', '\x2', '\x2', '\x2', '\x9FD', + '\x9E3', '\x3', '\x2', '\x2', '\x2', '\x9FD', '\x9EF', '\x3', '\x2', '\x2', + '\x2', '\x9FE', '\x19D', '\x3', '\x2', '\x2', '\x2', '\x9FF', '\xA04', + '\x5', '\x1AE', '\xD8', '\x2', '\xA00', '\xA01', '\a', 'M', '\x2', '\x2', + '\xA01', '\xA03', '\x5', '\x1AE', '\xD8', '\x2', '\xA02', '\xA00', '\x3', + '\x2', '\x2', '\x2', '\xA03', '\xA06', '\x3', '\x2', '\x2', '\x2', '\xA04', + '\xA02', '\x3', '\x2', '\x2', '\x2', '\xA04', '\xA05', '\x3', '\x2', '\x2', + '\x2', '\xA05', '\x19F', '\x3', '\x2', '\x2', '\x2', '\xA06', '\xA04', + '\x3', '\x2', '\x2', '\x2', '\xA07', '\xA08', '\x5', '<', '\x1F', '\x2', + '\xA08', '\xA0A', '\a', 'Q', '\x2', '\x2', '\xA09', '\xA0B', '\x5', '*', + '\x16', '\x2', '\xA0A', '\xA09', '\x3', '\x2', '\x2', '\x2', '\xA0A', + '\xA0B', '\x3', '\x2', '\x2', '\x2', '\xA0B', '\xA0C', '\x3', '\x2', '\x2', + '\x2', '\xA0C', '\xA0D', '\x5', '\x1EA', '\xF6', '\x2', '\xA0D', '\xA37', + '\x3', '\x2', '\x2', '\x2', '\xA0E', '\xA0F', '\x5', '\f', '\a', '\x2', + '\xA0F', '\xA11', '\a', 'Q', '\x2', '\x2', '\xA10', '\xA12', '\x5', '*', + '\x16', '\x2', '\xA11', '\xA10', '\x3', '\x2', '\x2', '\x2', '\xA11', + '\xA12', '\x3', '\x2', '\x2', '\x2', '\xA12', '\xA13', '\x3', '\x2', '\x2', + '\x2', '\xA13', '\xA14', '\x5', '\x1EA', '\xF6', '\x2', '\xA14', '\xA37', + '\x3', '\x2', '\x2', '\x2', '\xA15', '\xA16', '\x5', '\x16E', '\xB8', + '\x2', '\xA16', '\xA18', '\a', 'Q', '\x2', '\x2', '\xA17', '\xA19', '\x5', + '*', '\x16', '\x2', '\xA18', '\xA17', '\x3', '\x2', '\x2', '\x2', '\xA18', + '\xA19', '\x3', '\x2', '\x2', '\x2', '\xA19', '\xA1A', '\x3', '\x2', '\x2', + '\x2', '\xA1A', '\xA1B', '\x5', '\x1EA', '\xF6', '\x2', '\xA1B', '\xA37', + '\x3', '\x2', '\x2', '\x2', '\xA1C', '\xA1D', '\a', '\x30', '\x2', '\x2', + '\xA1D', '\xA1F', '\a', 'Q', '\x2', '\x2', '\xA1E', '\xA20', '\x5', '*', + '\x16', '\x2', '\xA1F', '\xA1E', '\x3', '\x2', '\x2', '\x2', '\xA1F', + '\xA20', '\x3', '\x2', '\x2', '\x2', '\xA20', '\xA21', '\x3', '\x2', '\x2', + '\x2', '\xA21', '\xA37', '\x5', '\x1EA', '\xF6', '\x2', '\xA22', '\xA23', + '\x5', '\x38', '\x1D', '\x2', '\xA23', '\xA24', '\a', 'N', '\x2', '\x2', + '\xA24', '\xA25', '\a', '\x30', '\x2', '\x2', '\xA25', '\xA27', '\a', + 'Q', '\x2', '\x2', '\xA26', '\xA28', '\x5', '*', '\x16', '\x2', '\xA27', + '\xA26', '\x3', '\x2', '\x2', '\x2', '\xA27', '\xA28', '\x3', '\x2', '\x2', + '\x2', '\xA28', '\xA29', '\x3', '\x2', '\x2', '\x2', '\xA29', '\xA2A', + '\x5', '\x1EA', '\xF6', '\x2', '\xA2A', '\xA37', '\x3', '\x2', '\x2', + '\x2', '\xA2B', '\xA2C', '\x5', '\x10', '\t', '\x2', '\xA2C', '\xA2E', + '\a', 'Q', '\x2', '\x2', '\xA2D', '\xA2F', '\x5', '*', '\x16', '\x2', + '\xA2E', '\xA2D', '\x3', '\x2', '\x2', '\x2', '\xA2E', '\xA2F', '\x3', + '\x2', '\x2', '\x2', '\xA2F', '\xA30', '\x3', '\x2', '\x2', '\x2', '\xA30', + '\xA31', '\a', '#', '\x2', '\x2', '\xA31', '\xA37', '\x3', '\x2', '\x2', + '\x2', '\xA32', '\xA33', '\x5', '\x1E', '\x10', '\x2', '\xA33', '\xA34', + '\a', 'Q', '\x2', '\x2', '\xA34', '\xA35', '\a', '#', '\x2', '\x2', '\xA35', + '\xA37', '\x3', '\x2', '\x2', '\x2', '\xA36', '\xA07', '\x3', '\x2', '\x2', + '\x2', '\xA36', '\xA0E', '\x3', '\x2', '\x2', '\x2', '\xA36', '\xA15', + '\x3', '\x2', '\x2', '\x2', '\xA36', '\xA1C', '\x3', '\x2', '\x2', '\x2', + '\xA36', '\xA22', '\x3', '\x2', '\x2', '\x2', '\xA36', '\xA2B', '\x3', + '\x2', '\x2', '\x2', '\xA36', '\xA32', '\x3', '\x2', '\x2', '\x2', '\xA37', + '\x1A1', '\x3', '\x2', '\x2', '\x2', '\xA38', '\xA3A', '\a', 'Q', '\x2', + '\x2', '\xA39', '\xA3B', '\x5', '*', '\x16', '\x2', '\xA3A', '\xA39', + '\x3', '\x2', '\x2', '\x2', '\xA3A', '\xA3B', '\x3', '\x2', '\x2', '\x2', + '\xA3B', '\xA3C', '\x3', '\x2', '\x2', '\x2', '\xA3C', '\xA3D', '\x5', + '\x1EA', '\xF6', '\x2', '\xA3D', '\x1A3', '\x3', '\x2', '\x2', '\x2', + '\xA3E', '\xA3F', '\x5', '<', '\x1F', '\x2', '\xA3F', '\xA41', '\a', 'Q', + '\x2', '\x2', '\xA40', '\xA42', '\x5', '*', '\x16', '\x2', '\xA41', '\xA40', + '\x3', '\x2', '\x2', '\x2', '\xA41', '\xA42', '\x3', '\x2', '\x2', '\x2', + '\xA42', '\xA43', '\x3', '\x2', '\x2', '\x2', '\xA43', '\xA44', '\x5', + '\x1EA', '\xF6', '\x2', '\xA44', '\xA67', '\x3', '\x2', '\x2', '\x2', + '\xA45', '\xA46', '\x5', '\f', '\a', '\x2', '\xA46', '\xA48', '\a', 'Q', + '\x2', '\x2', '\xA47', '\xA49', '\x5', '*', '\x16', '\x2', '\xA48', '\xA47', + '\x3', '\x2', '\x2', '\x2', '\xA48', '\xA49', '\x3', '\x2', '\x2', '\x2', + '\xA49', '\xA4A', '\x3', '\x2', '\x2', '\x2', '\xA4A', '\xA4B', '\x5', + '\x1EA', '\xF6', '\x2', '\xA4B', '\xA67', '\x3', '\x2', '\x2', '\x2', + '\xA4C', '\xA4D', '\a', '\x30', '\x2', '\x2', '\xA4D', '\xA4F', '\a', + 'Q', '\x2', '\x2', '\xA4E', '\xA50', '\x5', '*', '\x16', '\x2', '\xA4F', + '\xA4E', '\x3', '\x2', '\x2', '\x2', '\xA4F', '\xA50', '\x3', '\x2', '\x2', + '\x2', '\xA50', '\xA51', '\x3', '\x2', '\x2', '\x2', '\xA51', '\xA67', + '\x5', '\x1EA', '\xF6', '\x2', '\xA52', '\xA53', '\x5', '\x38', '\x1D', + '\x2', '\xA53', '\xA54', '\a', 'N', '\x2', '\x2', '\xA54', '\xA55', '\a', + '\x30', '\x2', '\x2', '\xA55', '\xA57', '\a', 'Q', '\x2', '\x2', '\xA56', + '\xA58', '\x5', '*', '\x16', '\x2', '\xA57', '\xA56', '\x3', '\x2', '\x2', + '\x2', '\xA57', '\xA58', '\x3', '\x2', '\x2', '\x2', '\xA58', '\xA59', + '\x3', '\x2', '\x2', '\x2', '\xA59', '\xA5A', '\x5', '\x1EA', '\xF6', + '\x2', '\xA5A', '\xA67', '\x3', '\x2', '\x2', '\x2', '\xA5B', '\xA5C', + '\x5', '\x10', '\t', '\x2', '\xA5C', '\xA5E', '\a', 'Q', '\x2', '\x2', + '\xA5D', '\xA5F', '\x5', '*', '\x16', '\x2', '\xA5E', '\xA5D', '\x3', + '\x2', '\x2', '\x2', '\xA5E', '\xA5F', '\x3', '\x2', '\x2', '\x2', '\xA5F', + '\xA60', '\x3', '\x2', '\x2', '\x2', '\xA60', '\xA61', '\a', '#', '\x2', + '\x2', '\xA61', '\xA67', '\x3', '\x2', '\x2', '\x2', '\xA62', '\xA63', + '\x5', '\x1E', '\x10', '\x2', '\xA63', '\xA64', '\a', 'Q', '\x2', '\x2', + '\xA64', '\xA65', '\a', '#', '\x2', '\x2', '\xA65', '\xA67', '\x3', '\x2', + '\x2', '\x2', '\xA66', '\xA3E', '\x3', '\x2', '\x2', '\x2', '\xA66', '\xA45', + '\x3', '\x2', '\x2', '\x2', '\xA66', '\xA4C', '\x3', '\x2', '\x2', '\x2', + '\xA66', '\xA52', '\x3', '\x2', '\x2', '\x2', '\xA66', '\xA5B', '\x3', + '\x2', '\x2', '\x2', '\xA66', '\xA62', '\x3', '\x2', '\x2', '\x2', '\xA67', + '\x1A5', '\x3', '\x2', '\x2', '\x2', '\xA68', '\xA69', '\a', '#', '\x2', + '\x2', '\xA69', '\xA6A', '\x5', '\x4', '\x3', '\x2', '\xA6A', '\xA6C', + '\x5', '\x1A8', '\xD5', '\x2', '\xA6B', '\xA6D', '\x5', ' ', '\x11', '\x2', + '\xA6C', '\xA6B', '\x3', '\x2', '\x2', '\x2', '\xA6C', '\xA6D', '\x3', + '\x2', '\x2', '\x2', '\xA6D', '\xA7F', '\x3', '\x2', '\x2', '\x2', '\xA6E', + '\xA6F', '\a', '#', '\x2', '\x2', '\xA6F', '\xA70', '\x5', '\xE', '\b', + '\x2', '\xA70', '\xA72', '\x5', '\x1A8', '\xD5', '\x2', '\xA71', '\xA73', + '\x5', ' ', '\x11', '\x2', '\xA72', '\xA71', '\x3', '\x2', '\x2', '\x2', + '\xA72', '\xA73', '\x3', '\x2', '\x2', '\x2', '\xA73', '\xA7F', '\x3', + '\x2', '\x2', '\x2', '\xA74', '\xA75', '\a', '#', '\x2', '\x2', '\xA75', + '\xA76', '\x5', '\x4', '\x3', '\x2', '\xA76', '\xA77', '\x5', ' ', '\x11', + '\x2', '\xA77', '\xA78', '\x5', '\x104', '\x83', '\x2', '\xA78', '\xA7F', + '\x3', '\x2', '\x2', '\x2', '\xA79', '\xA7A', '\a', '#', '\x2', '\x2', + '\xA7A', '\xA7B', '\x5', '\xE', '\b', '\x2', '\xA7B', '\xA7C', '\x5', + ' ', '\x11', '\x2', '\xA7C', '\xA7D', '\x5', '\x104', '\x83', '\x2', '\xA7D', + '\xA7F', '\x3', '\x2', '\x2', '\x2', '\xA7E', '\xA68', '\x3', '\x2', '\x2', + '\x2', '\xA7E', '\xA6E', '\x3', '\x2', '\x2', '\x2', '\xA7E', '\xA74', + '\x3', '\x2', '\x2', '\x2', '\xA7E', '\xA79', '\x3', '\x2', '\x2', '\x2', + '\xA7F', '\x1A7', '\x3', '\x2', '\x2', '\x2', '\xA80', '\xA82', '\x5', + '\x1AA', '\xD6', '\x2', '\xA81', '\xA80', '\x3', '\x2', '\x2', '\x2', + '\xA82', '\xA83', '\x3', '\x2', '\x2', '\x2', '\xA83', '\xA81', '\x3', + '\x2', '\x2', '\x2', '\xA83', '\xA84', '\x3', '\x2', '\x2', '\x2', '\xA84', + '\x1A9', '\x3', '\x2', '\x2', '\x2', '\xA85', '\xA87', '\x5', '\xF2', + 'z', '\x2', '\xA86', '\xA85', '\x3', '\x2', '\x2', '\x2', '\xA87', '\xA8A', + '\x3', '\x2', '\x2', '\x2', '\xA88', '\xA86', '\x3', '\x2', '\x2', '\x2', + '\xA88', '\xA89', '\x3', '\x2', '\x2', '\x2', '\xA89', '\xA8B', '\x3', + '\x2', '\x2', '\x2', '\xA8A', '\xA88', '\x3', '\x2', '\x2', '\x2', '\xA8B', + '\xA8C', '\a', 'J', '\x2', '\x2', '\xA8C', '\xA8D', '\x5', '\x1AE', '\xD8', + '\x2', '\xA8D', '\xA8E', '\a', 'K', '\x2', '\x2', '\xA8E', '\x1AB', '\x3', + '\x2', '\x2', '\x2', '\xA8F', '\xA90', '\x5', '\x1AE', '\xD8', '\x2', + '\xA90', '\x1AD', '\x3', '\x2', '\x2', '\x2', '\xA91', '\xA94', '\x5', + '\x1B0', '\xD9', '\x2', '\xA92', '\xA94', '\x5', '\x1B8', '\xDD', '\x2', + '\xA93', '\xA91', '\x3', '\x2', '\x2', '\x2', '\xA93', '\xA92', '\x3', + '\x2', '\x2', '\x2', '\xA94', '\x1AF', '\x3', '\x2', '\x2', '\x2', '\xA95', + '\xA96', '\x5', '\x1B2', '\xDA', '\x2', '\xA96', '\xA97', '\a', 'Y', '\x2', + '\x2', '\xA97', '\xA98', '\x5', '\x1B6', '\xDC', '\x2', '\xA98', '\x1B1', + '\x3', '\x2', '\x2', '\x2', '\xA99', '\xAA4', '\x5', '\x1EA', '\xF6', + '\x2', '\xA9A', '\xA9C', '\a', '\x46', '\x2', '\x2', '\xA9B', '\xA9D', + '\x5', '\xA2', 'R', '\x2', '\xA9C', '\xA9B', '\x3', '\x2', '\x2', '\x2', + '\xA9C', '\xA9D', '\x3', '\x2', '\x2', '\x2', '\xA9D', '\xA9E', '\x3', + '\x2', '\x2', '\x2', '\xA9E', '\xAA4', '\a', 'G', '\x2', '\x2', '\xA9F', + '\xAA0', '\a', '\x46', '\x2', '\x2', '\xAA0', '\xAA1', '\x5', '\x1B4', + '\xDB', '\x2', '\xAA1', '\xAA2', '\a', 'G', '\x2', '\x2', '\xAA2', '\xAA4', + '\x3', '\x2', '\x2', '\x2', '\xAA3', '\xA99', '\x3', '\x2', '\x2', '\x2', + '\xAA3', '\xA9A', '\x3', '\x2', '\x2', '\x2', '\xAA3', '\xA9F', '\x3', + '\x2', '\x2', '\x2', '\xAA4', '\x1B3', '\x3', '\x2', '\x2', '\x2', '\xAA5', + '\xAAA', '\x5', '\x1EA', '\xF6', '\x2', '\xAA6', '\xAA7', '\a', 'M', '\x2', + '\x2', '\xAA7', '\xAA9', '\x5', '\x1EA', '\xF6', '\x2', '\xAA8', '\xAA6', + '\x3', '\x2', '\x2', '\x2', '\xAA9', '\xAAC', '\x3', '\x2', '\x2', '\x2', + '\xAAA', '\xAA8', '\x3', '\x2', '\x2', '\x2', '\xAAA', '\xAAB', '\x3', + '\x2', '\x2', '\x2', '\xAAB', '\x1B5', '\x3', '\x2', '\x2', '\x2', '\xAAC', + '\xAAA', '\x3', '\x2', '\x2', '\x2', '\xAAD', '\xAB0', '\x5', '\x1AE', + '\xD8', '\x2', '\xAAE', '\xAB0', '\x5', '\x108', '\x85', '\x2', '\xAAF', + '\xAAD', '\x3', '\x2', '\x2', '\x2', '\xAAF', '\xAAE', '\x3', '\x2', '\x2', + '\x2', '\xAB0', '\x1B7', '\x3', '\x2', '\x2', '\x2', '\xAB1', '\xAB4', + '\x5', '\x1C0', '\xE1', '\x2', '\xAB2', '\xAB4', '\x5', '\x1BA', '\xDE', + '\x2', '\xAB3', '\xAB1', '\x3', '\x2', '\x2', '\x2', '\xAB3', '\xAB2', + '\x3', '\x2', '\x2', '\x2', '\xAB4', '\x1B9', '\x3', '\x2', '\x2', '\x2', + '\xAB5', '\xAB6', '\x5', '\x1BC', '\xDF', '\x2', '\xAB6', '\xAB7', '\x5', + '\x1BE', '\xE0', '\x2', '\xAB7', '\xAB8', '\x5', '\x1AE', '\xD8', '\x2', + '\xAB8', '\x1BB', '\x3', '\x2', '\x2', '\x2', '\xAB9', '\xABD', '\x5', + '<', '\x1F', '\x2', '\xABA', '\xABD', '\x5', '\x18C', '\xC7', '\x2', '\xABB', + '\xABD', '\x5', '\x192', '\xCA', '\x2', '\xABC', '\xAB9', '\x3', '\x2', + '\x2', '\x2', '\xABC', '\xABA', '\x3', '\x2', '\x2', '\x2', '\xABC', '\xABB', + '\x3', '\x2', '\x2', '\x2', '\xABD', '\x1BD', '\x3', '\x2', '\x2', '\x2', + '\xABE', '\xABF', '\t', '\x6', '\x2', '\x2', '\xABF', '\x1BF', '\x3', + '\x2', '\x2', '\x2', '\xAC0', '\xACA', '\x5', '\x1C2', '\xE2', '\x2', + '\xAC1', '\xAC2', '\x5', '\x1C2', '\xE2', '\x2', '\xAC2', '\xAC3', '\a', + 'W', '\x2', '\x2', '\xAC3', '\xAC4', '\x5', '\x1AE', '\xD8', '\x2', '\xAC4', + '\xAC7', '\a', 'X', '\x2', '\x2', '\xAC5', '\xAC8', '\x5', '\x1C0', '\xE1', + '\x2', '\xAC6', '\xAC8', '\x5', '\x1B0', '\xD9', '\x2', '\xAC7', '\xAC5', + '\x3', '\x2', '\x2', '\x2', '\xAC7', '\xAC6', '\x3', '\x2', '\x2', '\x2', + '\xAC8', '\xACA', '\x3', '\x2', '\x2', '\x2', '\xAC9', '\xAC0', '\x3', + '\x2', '\x2', '\x2', '\xAC9', '\xAC1', '\x3', '\x2', '\x2', '\x2', '\xACA', + '\x1C1', '\x3', '\x2', '\x2', '\x2', '\xACB', '\xACC', '\b', '\xE2', '\x1', + '\x2', '\xACC', '\xACD', '\x5', '\x1C4', '\xE3', '\x2', '\xACD', '\xAD3', + '\x3', '\x2', '\x2', '\x2', '\xACE', '\xACF', '\f', '\x3', '\x2', '\x2', + '\xACF', '\xAD0', '\a', '_', '\x2', '\x2', '\xAD0', '\xAD2', '\x5', '\x1C4', + '\xE3', '\x2', '\xAD1', '\xACE', '\x3', '\x2', '\x2', '\x2', '\xAD2', + '\xAD5', '\x3', '\x2', '\x2', '\x2', '\xAD3', '\xAD1', '\x3', '\x2', '\x2', + '\x2', '\xAD3', '\xAD4', '\x3', '\x2', '\x2', '\x2', '\xAD4', '\x1C3', + '\x3', '\x2', '\x2', '\x2', '\xAD5', '\xAD3', '\x3', '\x2', '\x2', '\x2', + '\xAD6', '\xAD7', '\b', '\xE3', '\x1', '\x2', '\xAD7', '\xAD8', '\x5', + '\x1C6', '\xE4', '\x2', '\xAD8', '\xADE', '\x3', '\x2', '\x2', '\x2', + '\xAD9', '\xADA', '\f', '\x3', '\x2', '\x2', '\xADA', '\xADB', '\a', '^', + '\x2', '\x2', '\xADB', '\xADD', '\x5', '\x1C6', '\xE4', '\x2', '\xADC', + '\xAD9', '\x3', '\x2', '\x2', '\x2', '\xADD', '\xAE0', '\x3', '\x2', '\x2', + '\x2', '\xADE', '\xADC', '\x3', '\x2', '\x2', '\x2', '\xADE', '\xADF', + '\x3', '\x2', '\x2', '\x2', '\xADF', '\x1C5', '\x3', '\x2', '\x2', '\x2', + '\xAE0', '\xADE', '\x3', '\x2', '\x2', '\x2', '\xAE1', '\xAE2', '\b', + '\xE4', '\x1', '\x2', '\xAE2', '\xAE3', '\x5', '\x1C8', '\xE5', '\x2', + '\xAE3', '\xAE9', '\x3', '\x2', '\x2', '\x2', '\xAE4', '\xAE5', '\f', + '\x3', '\x2', '\x2', '\xAE5', '\xAE6', '\a', 'g', '\x2', '\x2', '\xAE6', + '\xAE8', '\x5', '\x1C8', '\xE5', '\x2', '\xAE7', '\xAE4', '\x3', '\x2', + '\x2', '\x2', '\xAE8', '\xAEB', '\x3', '\x2', '\x2', '\x2', '\xAE9', '\xAE7', + '\x3', '\x2', '\x2', '\x2', '\xAE9', '\xAEA', '\x3', '\x2', '\x2', '\x2', + '\xAEA', '\x1C7', '\x3', '\x2', '\x2', '\x2', '\xAEB', '\xAE9', '\x3', + '\x2', '\x2', '\x2', '\xAEC', '\xAED', '\b', '\xE5', '\x1', '\x2', '\xAED', + '\xAEE', '\x5', '\x1CA', '\xE6', '\x2', '\xAEE', '\xAF4', '\x3', '\x2', + '\x2', '\x2', '\xAEF', '\xAF0', '\f', '\x3', '\x2', '\x2', '\xAF0', '\xAF1', + '\a', 'h', '\x2', '\x2', '\xAF1', '\xAF3', '\x5', '\x1CA', '\xE6', '\x2', + '\xAF2', '\xAEF', '\x3', '\x2', '\x2', '\x2', '\xAF3', '\xAF6', '\x3', + '\x2', '\x2', '\x2', '\xAF4', '\xAF2', '\x3', '\x2', '\x2', '\x2', '\xAF4', + '\xAF5', '\x3', '\x2', '\x2', '\x2', '\xAF5', '\x1C9', '\x3', '\x2', '\x2', + '\x2', '\xAF6', '\xAF4', '\x3', '\x2', '\x2', '\x2', '\xAF7', '\xAF8', + '\b', '\xE6', '\x1', '\x2', '\xAF8', '\xAF9', '\x5', '\x1CC', '\xE7', + '\x2', '\xAF9', '\xAFF', '\x3', '\x2', '\x2', '\x2', '\xAFA', '\xAFB', + '\f', '\x3', '\x2', '\x2', '\xAFB', '\xAFC', '\a', '\x66', '\x2', '\x2', + '\xAFC', '\xAFE', '\x5', '\x1CC', '\xE7', '\x2', '\xAFD', '\xAFA', '\x3', + '\x2', '\x2', '\x2', '\xAFE', '\xB01', '\x3', '\x2', '\x2', '\x2', '\xAFF', + '\xAFD', '\x3', '\x2', '\x2', '\x2', '\xAFF', '\xB00', '\x3', '\x2', '\x2', + '\x2', '\xB00', '\x1CB', '\x3', '\x2', '\x2', '\x2', '\xB01', '\xAFF', + '\x3', '\x2', '\x2', '\x2', '\xB02', '\xB03', '\b', '\xE7', '\x1', '\x2', + '\xB03', '\xB04', '\x5', '\x1CE', '\xE8', '\x2', '\xB04', '\xB0D', '\x3', + '\x2', '\x2', '\x2', '\xB05', '\xB06', '\f', '\x4', '\x2', '\x2', '\xB06', + '\xB07', '\a', 'Z', '\x2', '\x2', '\xB07', '\xB0C', '\x5', '\x1CE', '\xE8', + '\x2', '\xB08', '\xB09', '\f', '\x3', '\x2', '\x2', '\xB09', '\xB0A', + '\a', ']', '\x2', '\x2', '\xB0A', '\xB0C', '\x5', '\x1CE', '\xE8', '\x2', + '\xB0B', '\xB05', '\x3', '\x2', '\x2', '\x2', '\xB0B', '\xB08', '\x3', + '\x2', '\x2', '\x2', '\xB0C', '\xB0F', '\x3', '\x2', '\x2', '\x2', '\xB0D', + '\xB0B', '\x3', '\x2', '\x2', '\x2', '\xB0D', '\xB0E', '\x3', '\x2', '\x2', + '\x2', '\xB0E', '\x1CD', '\x3', '\x2', '\x2', '\x2', '\xB0F', '\xB0D', + '\x3', '\x2', '\x2', '\x2', '\xB10', '\xB11', '\b', '\xE8', '\x1', '\x2', + '\xB11', '\xB12', '\x5', '\x1D0', '\xE9', '\x2', '\xB12', '\xB24', '\x3', + '\x2', '\x2', '\x2', '\xB13', '\xB14', '\f', '\a', '\x2', '\x2', '\xB14', + '\xB15', '\a', 'T', '\x2', '\x2', '\xB15', '\xB23', '\x5', '\x1D0', '\xE9', + '\x2', '\xB16', '\xB17', '\f', '\x6', '\x2', '\x2', '\xB17', '\xB18', + '\a', 'S', '\x2', '\x2', '\xB18', '\xB23', '\x5', '\x1D0', '\xE9', '\x2', + '\xB19', '\xB1A', '\f', '\x5', '\x2', '\x2', '\xB1A', '\xB1B', '\a', '[', + '\x2', '\x2', '\xB1B', '\xB23', '\x5', '\x1D0', '\xE9', '\x2', '\xB1C', + '\xB1D', '\f', '\x4', '\x2', '\x2', '\xB1D', '\xB1E', '\a', '\\', '\x2', + '\x2', '\xB1E', '\xB23', '\x5', '\x1D0', '\xE9', '\x2', '\xB1F', '\xB20', + '\f', '\x3', '\x2', '\x2', '\xB20', '\xB21', '\a', '\x1D', '\x2', '\x2', + '\xB21', '\xB23', '\x5', '\f', '\a', '\x2', '\xB22', '\xB13', '\x3', '\x2', + '\x2', '\x2', '\xB22', '\xB16', '\x3', '\x2', '\x2', '\x2', '\xB22', '\xB19', + '\x3', '\x2', '\x2', '\x2', '\xB22', '\xB1C', '\x3', '\x2', '\x2', '\x2', + '\xB22', '\xB1F', '\x3', '\x2', '\x2', '\x2', '\xB23', '\xB26', '\x3', + '\x2', '\x2', '\x2', '\xB24', '\xB22', '\x3', '\x2', '\x2', '\x2', '\xB24', + '\xB25', '\x3', '\x2', '\x2', '\x2', '\xB25', '\x1CF', '\x3', '\x2', '\x2', + '\x2', '\xB26', '\xB24', '\x3', '\x2', '\x2', '\x2', '\xB27', '\xB28', + '\b', '\xE9', '\x1', '\x2', '\xB28', '\xB29', '\x5', '\x1D2', '\xEA', + '\x2', '\xB29', '\xB3B', '\x3', '\x2', '\x2', '\x2', '\xB2A', '\xB2B', + '\f', '\x5', '\x2', '\x2', '\xB2B', '\xB2C', '\a', 'T', '\x2', '\x2', + '\xB2C', '\xB2D', '\a', 'T', '\x2', '\x2', '\xB2D', '\xB3A', '\x5', '\x1D2', + '\xEA', '\x2', '\xB2E', '\xB2F', '\f', '\x4', '\x2', '\x2', '\xB2F', '\xB30', + '\a', 'S', '\x2', '\x2', '\xB30', '\xB31', '\x6', '\xE9', '\x14', '\x2', + '\xB31', '\xB32', '\a', 'S', '\x2', '\x2', '\xB32', '\xB33', '\x6', '\xE9', + '\x15', '\x2', '\xB33', '\xB3A', '\x5', '\x1D2', '\xEA', '\x2', '\xB34', + '\xB35', '\f', '\x3', '\x2', '\x2', '\xB35', '\xB36', '\a', 'S', '\x2', + '\x2', '\xB36', '\xB37', '\a', 'S', '\x2', '\x2', '\xB37', '\xB38', '\a', + 'S', '\x2', '\x2', '\xB38', '\xB3A', '\x5', '\x1D2', '\xEA', '\x2', '\xB39', + '\xB2A', '\x3', '\x2', '\x2', '\x2', '\xB39', '\xB2E', '\x3', '\x2', '\x2', + '\x2', '\xB39', '\xB34', '\x3', '\x2', '\x2', '\x2', '\xB3A', '\xB3D', + '\x3', '\x2', '\x2', '\x2', '\xB3B', '\xB39', '\x3', '\x2', '\x2', '\x2', + '\xB3B', '\xB3C', '\x3', '\x2', '\x2', '\x2', '\xB3C', '\x1D1', '\x3', + '\x2', '\x2', '\x2', '\xB3D', '\xB3B', '\x3', '\x2', '\x2', '\x2', '\xB3E', + '\xB3F', '\b', '\xEA', '\x1', '\x2', '\xB3F', '\xB40', '\x5', '\x1D4', + '\xEB', '\x2', '\xB40', '\xB49', '\x3', '\x2', '\x2', '\x2', '\xB41', + '\xB42', '\f', '\x4', '\x2', '\x2', '\xB42', '\xB43', '\a', '\x62', '\x2', + '\x2', '\xB43', '\xB48', '\x5', '\x1D4', '\xEB', '\x2', '\xB44', '\xB45', + '\f', '\x3', '\x2', '\x2', '\xB45', '\xB46', '\a', '\x63', '\x2', '\x2', + '\xB46', '\xB48', '\x5', '\x1D4', '\xEB', '\x2', '\xB47', '\xB41', '\x3', + '\x2', '\x2', '\x2', '\xB47', '\xB44', '\x3', '\x2', '\x2', '\x2', '\xB48', + '\xB4B', '\x3', '\x2', '\x2', '\x2', '\xB49', '\xB47', '\x3', '\x2', '\x2', + '\x2', '\xB49', '\xB4A', '\x3', '\x2', '\x2', '\x2', '\xB4A', '\x1D3', + '\x3', '\x2', '\x2', '\x2', '\xB4B', '\xB49', '\x3', '\x2', '\x2', '\x2', + '\xB4C', '\xB4D', '\b', '\xEB', '\x1', '\x2', '\xB4D', '\xB4E', '\x5', + '\x1D6', '\xEC', '\x2', '\xB4E', '\xB5A', '\x3', '\x2', '\x2', '\x2', + '\xB4F', '\xB50', '\f', '\x5', '\x2', '\x2', '\xB50', '\xB51', '\a', '\x64', + '\x2', '\x2', '\xB51', '\xB59', '\x5', '\x1D6', '\xEC', '\x2', '\xB52', + '\xB53', '\f', '\x4', '\x2', '\x2', '\xB53', '\xB54', '\a', '\x65', '\x2', + '\x2', '\xB54', '\xB59', '\x5', '\x1D6', '\xEC', '\x2', '\xB55', '\xB56', + '\f', '\x3', '\x2', '\x2', '\xB56', '\xB57', '\a', 'i', '\x2', '\x2', + '\xB57', '\xB59', '\x5', '\x1D6', '\xEC', '\x2', '\xB58', '\xB4F', '\x3', + '\x2', '\x2', '\x2', '\xB58', '\xB52', '\x3', '\x2', '\x2', '\x2', '\xB58', + '\xB55', '\x3', '\x2', '\x2', '\x2', '\xB59', '\xB5C', '\x3', '\x2', '\x2', + '\x2', '\xB5A', '\xB58', '\x3', '\x2', '\x2', '\x2', '\xB5A', '\xB5B', + '\x3', '\x2', '\x2', '\x2', '\xB5B', '\x1D5', '\x3', '\x2', '\x2', '\x2', + '\xB5C', '\xB5A', '\x3', '\x2', '\x2', '\x2', '\xB5D', '\xB65', '\x5', + '\x1D8', '\xED', '\x2', '\xB5E', '\xB65', '\x5', '\x1DA', '\xEE', '\x2', + '\xB5F', '\xB60', '\a', '\x62', '\x2', '\x2', '\xB60', '\xB65', '\x5', + '\x1D6', '\xEC', '\x2', '\xB61', '\xB62', '\a', '\x63', '\x2', '\x2', + '\xB62', '\xB65', '\x5', '\x1D6', '\xEC', '\x2', '\xB63', '\xB65', '\x5', + '\x1DC', '\xEF', '\x2', '\xB64', '\xB5D', '\x3', '\x2', '\x2', '\x2', + '\xB64', '\xB5E', '\x3', '\x2', '\x2', '\x2', '\xB64', '\xB5F', '\x3', + '\x2', '\x2', '\x2', '\xB64', '\xB61', '\x3', '\x2', '\x2', '\x2', '\xB64', + '\xB63', '\x3', '\x2', '\x2', '\x2', '\xB65', '\x1D7', '\x3', '\x2', '\x2', + '\x2', '\xB66', '\xB67', '\a', '`', '\x2', '\x2', '\xB67', '\xB68', '\x5', + '\x1D6', '\xEC', '\x2', '\xB68', '\x1D9', '\x3', '\x2', '\x2', '\x2', + '\xB69', '\xB6A', '\a', '\x61', '\x2', '\x2', '\xB6A', '\xB6B', '\x5', + '\x1D6', '\xEC', '\x2', '\xB6B', '\x1DB', '\x3', '\x2', '\x2', '\x2', + '\xB6C', '\xB73', '\x5', '\x1DE', '\xF0', '\x2', '\xB6D', '\xB6E', '\a', + 'V', '\x2', '\x2', '\xB6E', '\xB73', '\x5', '\x1D6', '\xEC', '\x2', '\xB6F', + '\xB70', '\a', 'U', '\x2', '\x2', '\xB70', '\xB73', '\x5', '\x1D6', '\xEC', + '\x2', '\xB71', '\xB73', '\x5', '\x1E8', '\xF5', '\x2', '\xB72', '\xB6C', + '\x3', '\x2', '\x2', '\x2', '\xB72', '\xB6D', '\x3', '\x2', '\x2', '\x2', + '\xB72', '\xB6F', '\x3', '\x2', '\x2', '\x2', '\xB72', '\xB71', '\x3', + '\x2', '\x2', '\x2', '\xB73', '\x1DD', '\x3', '\x2', '\x2', '\x2', '\xB74', + '\xB77', '\x5', '\x16E', '\xB8', '\x2', '\xB75', '\xB77', '\x5', '<', + '\x1F', '\x2', '\xB76', '\xB74', '\x3', '\x2', '\x2', '\x2', '\xB76', + '\xB75', '\x3', '\x2', '\x2', '\x2', '\xB77', '\xB7C', '\x3', '\x2', '\x2', + '\x2', '\xB78', '\xB7B', '\x5', '\x1E2', '\xF2', '\x2', '\xB79', '\xB7B', + '\x5', '\x1E6', '\xF4', '\x2', '\xB7A', '\xB78', '\x3', '\x2', '\x2', + '\x2', '\xB7A', '\xB79', '\x3', '\x2', '\x2', '\x2', '\xB7B', '\xB7E', + '\x3', '\x2', '\x2', '\x2', '\xB7C', '\xB7A', '\x3', '\x2', '\x2', '\x2', + '\xB7C', '\xB7D', '\x3', '\x2', '\x2', '\x2', '\xB7D', '\x1DF', '\x3', + '\x2', '\x2', '\x2', '\xB7E', '\xB7C', '\x3', '\x2', '\x2', '\x2', '\xB7F', + '\xB80', '\x5', '\x1DE', '\xF0', '\x2', '\xB80', '\xB81', '\a', '`', '\x2', + '\x2', '\xB81', '\x1E1', '\x3', '\x2', '\x2', '\x2', '\xB82', '\xB83', + '\a', '`', '\x2', '\x2', '\xB83', '\x1E3', '\x3', '\x2', '\x2', '\x2', + '\xB84', '\xB85', '\x5', '\x1DE', '\xF0', '\x2', '\xB85', '\xB86', '\a', + '\x61', '\x2', '\x2', '\xB86', '\x1E5', '\x3', '\x2', '\x2', '\x2', '\xB87', + '\xB88', '\a', '\x61', '\x2', '\x2', '\xB88', '\x1E7', '\x3', '\x2', '\x2', + '\x2', '\xB89', '\xB8A', '\a', '\x46', '\x2', '\x2', '\xB8A', '\xB8B', + '\x5', '\x4', '\x3', '\x2', '\xB8B', '\xB8C', '\a', 'G', '\x2', '\x2', + '\xB8C', '\xB8D', '\x5', '\x1D6', '\xEC', '\x2', '\xB8D', '\xBA5', '\x3', + '\x2', '\x2', '\x2', '\xB8E', '\xB8F', '\a', '\x46', '\x2', '\x2', '\xB8F', + '\xB93', '\x5', '\f', '\a', '\x2', '\xB90', '\xB92', '\x5', '(', '\x15', + '\x2', '\xB91', '\xB90', '\x3', '\x2', '\x2', '\x2', '\xB92', '\xB95', + '\x3', '\x2', '\x2', '\x2', '\xB93', '\xB91', '\x3', '\x2', '\x2', '\x2', + '\xB93', '\xB94', '\x3', '\x2', '\x2', '\x2', '\xB94', '\xB96', '\x3', + '\x2', '\x2', '\x2', '\xB95', '\xB93', '\x3', '\x2', '\x2', '\x2', '\xB96', + '\xB97', '\a', 'G', '\x2', '\x2', '\xB97', '\xB98', '\x5', '\x1DC', '\xEF', + '\x2', '\xB98', '\xBA5', '\x3', '\x2', '\x2', '\x2', '\xB99', '\xB9A', + '\a', '\x46', '\x2', '\x2', '\xB9A', '\xB9E', '\x5', '\f', '\a', '\x2', + '\xB9B', '\xB9D', '\x5', '(', '\x15', '\x2', '\xB9C', '\xB9B', '\x3', + '\x2', '\x2', '\x2', '\xB9D', '\xBA0', '\x3', '\x2', '\x2', '\x2', '\xB9E', + '\xB9C', '\x3', '\x2', '\x2', '\x2', '\xB9E', '\xB9F', '\x3', '\x2', '\x2', + '\x2', '\xB9F', '\xBA1', '\x3', '\x2', '\x2', '\x2', '\xBA0', '\xB9E', + '\x3', '\x2', '\x2', '\x2', '\xBA1', '\xBA2', '\a', 'G', '\x2', '\x2', + '\xBA2', '\xBA3', '\x5', '\x1B0', '\xD9', '\x2', '\xBA3', '\xBA5', '\x3', + '\x2', '\x2', '\x2', '\xBA4', '\xB89', '\x3', '\x2', '\x2', '\x2', '\xBA4', + '\xB8E', '\x3', '\x2', '\x2', '\x2', '\xBA4', '\xB99', '\x3', '\x2', '\x2', + '\x2', '\xBA5', '\x1E9', '\x3', '\x2', '\x2', '\x2', '\xBA6', '\xBA7', + '\t', '\a', '\x2', '\x2', '\xBA7', '\x1EB', '\x3', '\x2', '\x2', '\x2', + '\x156', '\x1F1', '\x1F8', '\x1FC', '\x200', '\x209', '\x20D', '\x211', + '\x213', '\x219', '\x21E', '\x225', '\x22A', '\x22C', '\x232', '\x237', + '\x23C', '\x241', '\x24C', '\x25A', '\x25F', '\x267', '\x26E', '\x274', + '\x279', '\x284', '\x287', '\x295', '\x29A', '\x29F', '\x2A4', '\x2AA', + '\x2B4', '\x2BF', '\x2C7', '\x2D1', '\x2D9', '\x2E5', '\x2EA', '\x2ED', + '\x2F2', '\x2F8', '\x300', '\x308', '\x315', '\x332', '\x337', '\x33B', + '\x343', '\x34C', '\x35A', '\x35D', '\x369', '\x36C', '\x37C', '\x381', + '\x387', '\x38C', '\x392', '\x395', '\x398', '\x3A4', '\x3AF', '\x3BD', + '\x3C4', '\x3CD', '\x3D4', '\x3D9', '\x3E8', '\x3EF', '\x3F5', '\x3F9', + '\x3FD', '\x401', '\x405', '\x40A', '\x40E', '\x412', '\x414', '\x419', + '\x420', '\x425', '\x427', '\x42D', '\x432', '\x436', '\x449', '\x44E', + '\x45E', '\x463', '\x469', '\x46F', '\x471', '\x475', '\x47A', '\x47E', + '\x486', '\x48D', '\x495', '\x498', '\x49D', '\x4A5', '\x4AA', '\x4B1', + '\x4B8', '\x4BD', '\x4C4', '\x4D0', '\x4D5', '\x4D9', '\x4E3', '\x4E8', + '\x4F0', '\x4F3', '\x4F8', '\x500', '\x503', '\x508', '\x50D', '\x512', + '\x517', '\x51E', '\x523', '\x52B', '\x530', '\x535', '\x53A', '\x540', + '\x546', '\x549', '\x54C', '\x555', '\x55B', '\x561', '\x564', '\x567', + '\x56F', '\x574', '\x579', '\x57F', '\x582', '\x58D', '\x596', '\x5A0', + '\x5A5', '\x5B0', '\x5B5', '\x5C2', '\x5C7', '\x5D3', '\x5DD', '\x5E2', + '\x5EA', '\x5ED', '\x5F4', '\x5FC', '\x602', '\x60B', '\x615', '\x619', + '\x61C', '\x625', '\x633', '\x636', '\x63F', '\x644', '\x64B', '\x650', + '\x658', '\x664', '\x66B', '\x679', '\x68F', '\x6B1', '\x6BD', '\x6C3', + '\x6CE', '\x6DA', '\x6F4', '\x6F8', '\x6FD', '\x701', '\x705', '\x70D', + '\x711', '\x715', '\x71C', '\x725', '\x72D', '\x73C', '\x748', '\x74E', + '\x754', '\x769', '\x76E', '\x773', '\x77E', '\x789', '\x793', '\x796', + '\x79B', '\x7A4', '\x7AA', '\x7B3', '\x7B7', '\x7BB', '\x7C0', '\x7D3', + '\x7DD', '\x7F3', '\x7FA', '\x802', '\x80A', '\x815', '\x82C', '\x836', + '\x841', '\x857', '\x85C', '\x862', '\x86A', '\x86E', '\x873', '\x87B', + '\x881', '\x885', '\x889', '\x88D', '\x893', '\x898', '\x89D', '\x8A1', + '\x8A5', '\x8AB', '\x8B0', '\x8B5', '\x8B9', '\x8BD', '\x8BF', '\x8C4', + '\x8C9', '\x8CE', '\x8D2', '\x8D6', '\x8DA', '\x8DF', '\x8E7', '\x8ED', + '\x8F1', '\x8F5', '\x8F9', '\x8FF', '\x904', '\x909', '\x90D', '\x911', + '\x913', '\x918', '\x927', '\x935', '\x941', '\x94A', '\x959', '\x966', + '\x96F', '\x975', '\x97C', '\x981', '\x988', '\x98D', '\x994', '\x999', + '\x9A0', '\x9A5', '\x9AE', '\x9B3', '\x9B7', '\x9BB', '\x9C0', '\x9C7', + '\x9CE', '\x9D3', '\x9DA', '\x9DF', '\x9E6', '\x9EB', '\x9F4', '\x9F9', + '\x9FD', '\xA04', '\xA0A', '\xA11', '\xA18', '\xA1F', '\xA27', '\xA2E', + '\xA36', '\xA3A', '\xA41', '\xA48', '\xA4F', '\xA57', '\xA5E', '\xA66', + '\xA6C', '\xA72', '\xA7E', '\xA83', '\xA88', '\xA93', '\xA9C', '\xAA3', + '\xAAA', '\xAAF', '\xAB3', '\xABC', '\xAC7', '\xAC9', '\xAD3', '\xADE', + '\xAE9', '\xAF4', '\xAFF', '\xB0B', '\xB0D', '\xB22', '\xB24', '\xB39', + '\xB3B', '\xB47', '\xB49', '\xB58', '\xB5A', '\xB64', '\xB72', '\xB76', + '\xB7A', '\xB7C', '\xB93', '\xB9E', '\xBA4', + }; + + public static readonly ATN _ATN = + new ATNDeserializer().Deserialize(_serializedATN); + + +} diff --git a/Tests.Runtime.Standard/Java9/Java9ParserBaseListener.cs b/Tests.Runtime.Standard/Java9/Java9ParserBaseListener.cs new file mode 100644 index 0000000..c2d1b12 --- /dev/null +++ b/Tests.Runtime.Standard/Java9/Java9ParserBaseListener.cs @@ -0,0 +1,2990 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// ANTLR Version: 4.7.2 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +// Generated from C:\Users\Spitz\source\repos\AntlrBug_40\AntlrConsole3\Java9Parser.g4 by ANTLR 4.7.2 + +// Unreachable code detected +#pragma warning disable 0162 +// The variable '...' is assigned but its value is never used +#pragma warning disable 0219 +// Missing XML comment for publicly visible type or member '...' +#pragma warning disable 1591 +// Ambiguous reference in cref attribute +#pragma warning disable 419 + + +using Antlr4.Runtime.Misc; +using IErrorNode = Antlr4.Runtime.Tree.IErrorNode; +using ITerminalNode = Antlr4.Runtime.Tree.ITerminalNode; +using IToken = Antlr4.Runtime.IToken; +using ParserRuleContext = Antlr4.Runtime.ParserRuleContext; + +/// +/// This class provides an empty implementation of , +/// which can be extended to create a listener which only needs to handle a subset +/// of the available methods. +/// +[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.7.2")] +[System.CLSCompliant(false)] +public partial class Java9ParserBaseListener : IJava9ParserListener { + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterLiteral([NotNull] Java9Parser.LiteralContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitLiteral([NotNull] Java9Parser.LiteralContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPrimitiveType([NotNull] Java9Parser.PrimitiveTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPrimitiveType([NotNull] Java9Parser.PrimitiveTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterNumericType([NotNull] Java9Parser.NumericTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitNumericType([NotNull] Java9Parser.NumericTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterIntegralType([NotNull] Java9Parser.IntegralTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitIntegralType([NotNull] Java9Parser.IntegralTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterFloatingPointType([NotNull] Java9Parser.FloatingPointTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitFloatingPointType([NotNull] Java9Parser.FloatingPointTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterReferenceType([NotNull] Java9Parser.ReferenceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitReferenceType([NotNull] Java9Parser.ReferenceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassOrInterfaceType([NotNull] Java9Parser.ClassOrInterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassOrInterfaceType([NotNull] Java9Parser.ClassOrInterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassType([NotNull] Java9Parser.ClassTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassType([NotNull] Java9Parser.ClassTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassType_lf_classOrInterfaceType([NotNull] Java9Parser.ClassType_lf_classOrInterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassType_lf_classOrInterfaceType([NotNull] Java9Parser.ClassType_lf_classOrInterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassType_lfno_classOrInterfaceType([NotNull] Java9Parser.ClassType_lfno_classOrInterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassType_lfno_classOrInterfaceType([NotNull] Java9Parser.ClassType_lfno_classOrInterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInterfaceType([NotNull] Java9Parser.InterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInterfaceType([NotNull] Java9Parser.InterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInterfaceType_lf_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lf_classOrInterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInterfaceType_lf_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lf_classOrInterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInterfaceType_lfno_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lfno_classOrInterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInterfaceType_lfno_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lfno_classOrInterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeVariable([NotNull] Java9Parser.TypeVariableContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeVariable([NotNull] Java9Parser.TypeVariableContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterArrayType([NotNull] Java9Parser.ArrayTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitArrayType([NotNull] Java9Parser.ArrayTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterDims([NotNull] Java9Parser.DimsContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitDims([NotNull] Java9Parser.DimsContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeParameter([NotNull] Java9Parser.TypeParameterContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeParameter([NotNull] Java9Parser.TypeParameterContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeParameterModifier([NotNull] Java9Parser.TypeParameterModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeParameterModifier([NotNull] Java9Parser.TypeParameterModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeBound([NotNull] Java9Parser.TypeBoundContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeBound([NotNull] Java9Parser.TypeBoundContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAdditionalBound([NotNull] Java9Parser.AdditionalBoundContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAdditionalBound([NotNull] Java9Parser.AdditionalBoundContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeArguments([NotNull] Java9Parser.TypeArgumentsContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeArguments([NotNull] Java9Parser.TypeArgumentsContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeArgumentList([NotNull] Java9Parser.TypeArgumentListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeArgumentList([NotNull] Java9Parser.TypeArgumentListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeArgument([NotNull] Java9Parser.TypeArgumentContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeArgument([NotNull] Java9Parser.TypeArgumentContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterWildcard([NotNull] Java9Parser.WildcardContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitWildcard([NotNull] Java9Parser.WildcardContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterWildcardBounds([NotNull] Java9Parser.WildcardBoundsContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitWildcardBounds([NotNull] Java9Parser.WildcardBoundsContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterModuleName([NotNull] Java9Parser.ModuleNameContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitModuleName([NotNull] Java9Parser.ModuleNameContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPackageName([NotNull] Java9Parser.PackageNameContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPackageName([NotNull] Java9Parser.PackageNameContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeName([NotNull] Java9Parser.TypeNameContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeName([NotNull] Java9Parser.TypeNameContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPackageOrTypeName([NotNull] Java9Parser.PackageOrTypeNameContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPackageOrTypeName([NotNull] Java9Parser.PackageOrTypeNameContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterExpressionName([NotNull] Java9Parser.ExpressionNameContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitExpressionName([NotNull] Java9Parser.ExpressionNameContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodName([NotNull] Java9Parser.MethodNameContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodName([NotNull] Java9Parser.MethodNameContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAmbiguousName([NotNull] Java9Parser.AmbiguousNameContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAmbiguousName([NotNull] Java9Parser.AmbiguousNameContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterCompilationUnit([NotNull] Java9Parser.CompilationUnitContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitCompilationUnit([NotNull] Java9Parser.CompilationUnitContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterOrdinaryCompilation([NotNull] Java9Parser.OrdinaryCompilationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitOrdinaryCompilation([NotNull] Java9Parser.OrdinaryCompilationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterModularCompilation([NotNull] Java9Parser.ModularCompilationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitModularCompilation([NotNull] Java9Parser.ModularCompilationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPackageDeclaration([NotNull] Java9Parser.PackageDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPackageDeclaration([NotNull] Java9Parser.PackageDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPackageModifier([NotNull] Java9Parser.PackageModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPackageModifier([NotNull] Java9Parser.PackageModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterImportDeclaration([NotNull] Java9Parser.ImportDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitImportDeclaration([NotNull] Java9Parser.ImportDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSingleTypeImportDeclaration([NotNull] Java9Parser.SingleTypeImportDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSingleTypeImportDeclaration([NotNull] Java9Parser.SingleTypeImportDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeImportOnDemandDeclaration([NotNull] Java9Parser.TypeImportOnDemandDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeImportOnDemandDeclaration([NotNull] Java9Parser.TypeImportOnDemandDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSingleStaticImportDeclaration([NotNull] Java9Parser.SingleStaticImportDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSingleStaticImportDeclaration([NotNull] Java9Parser.SingleStaticImportDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterStaticImportOnDemandDeclaration([NotNull] Java9Parser.StaticImportOnDemandDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitStaticImportOnDemandDeclaration([NotNull] Java9Parser.StaticImportOnDemandDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeDeclaration([NotNull] Java9Parser.TypeDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeDeclaration([NotNull] Java9Parser.TypeDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterModuleDeclaration([NotNull] Java9Parser.ModuleDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitModuleDeclaration([NotNull] Java9Parser.ModuleDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterModuleDirective([NotNull] Java9Parser.ModuleDirectiveContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitModuleDirective([NotNull] Java9Parser.ModuleDirectiveContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterRequiresModifier([NotNull] Java9Parser.RequiresModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitRequiresModifier([NotNull] Java9Parser.RequiresModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassDeclaration([NotNull] Java9Parser.ClassDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassDeclaration([NotNull] Java9Parser.ClassDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterNormalClassDeclaration([NotNull] Java9Parser.NormalClassDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitNormalClassDeclaration([NotNull] Java9Parser.NormalClassDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassModifier([NotNull] Java9Parser.ClassModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassModifier([NotNull] Java9Parser.ClassModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeParameters([NotNull] Java9Parser.TypeParametersContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeParameters([NotNull] Java9Parser.TypeParametersContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeParameterList([NotNull] Java9Parser.TypeParameterListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeParameterList([NotNull] Java9Parser.TypeParameterListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSuperclass([NotNull] Java9Parser.SuperclassContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSuperclass([NotNull] Java9Parser.SuperclassContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSuperinterfaces([NotNull] Java9Parser.SuperinterfacesContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSuperinterfaces([NotNull] Java9Parser.SuperinterfacesContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInterfaceTypeList([NotNull] Java9Parser.InterfaceTypeListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInterfaceTypeList([NotNull] Java9Parser.InterfaceTypeListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassBody([NotNull] Java9Parser.ClassBodyContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassBody([NotNull] Java9Parser.ClassBodyContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassBodyDeclaration([NotNull] Java9Parser.ClassBodyDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassBodyDeclaration([NotNull] Java9Parser.ClassBodyDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassMemberDeclaration([NotNull] Java9Parser.ClassMemberDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassMemberDeclaration([NotNull] Java9Parser.ClassMemberDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterFieldDeclaration([NotNull] Java9Parser.FieldDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitFieldDeclaration([NotNull] Java9Parser.FieldDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterFieldModifier([NotNull] Java9Parser.FieldModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitFieldModifier([NotNull] Java9Parser.FieldModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterVariableDeclaratorList([NotNull] Java9Parser.VariableDeclaratorListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitVariableDeclaratorList([NotNull] Java9Parser.VariableDeclaratorListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterVariableDeclarator([NotNull] Java9Parser.VariableDeclaratorContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitVariableDeclarator([NotNull] Java9Parser.VariableDeclaratorContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterVariableDeclaratorId([NotNull] Java9Parser.VariableDeclaratorIdContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitVariableDeclaratorId([NotNull] Java9Parser.VariableDeclaratorIdContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterVariableInitializer([NotNull] Java9Parser.VariableInitializerContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitVariableInitializer([NotNull] Java9Parser.VariableInitializerContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannType([NotNull] Java9Parser.UnannTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannType([NotNull] Java9Parser.UnannTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannPrimitiveType([NotNull] Java9Parser.UnannPrimitiveTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannPrimitiveType([NotNull] Java9Parser.UnannPrimitiveTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannReferenceType([NotNull] Java9Parser.UnannReferenceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannReferenceType([NotNull] Java9Parser.UnannReferenceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannClassOrInterfaceType([NotNull] Java9Parser.UnannClassOrInterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannClassOrInterfaceType([NotNull] Java9Parser.UnannClassOrInterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannClassType([NotNull] Java9Parser.UnannClassTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannClassType([NotNull] Java9Parser.UnannClassTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannClassType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannClassType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannClassType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannClassType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannInterfaceType([NotNull] Java9Parser.UnannInterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannInterfaceType([NotNull] Java9Parser.UnannInterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannInterfaceType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannInterfaceType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannInterfaceType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannInterfaceType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannTypeVariable([NotNull] Java9Parser.UnannTypeVariableContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannTypeVariable([NotNull] Java9Parser.UnannTypeVariableContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnannArrayType([NotNull] Java9Parser.UnannArrayTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnannArrayType([NotNull] Java9Parser.UnannArrayTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodDeclaration([NotNull] Java9Parser.MethodDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodDeclaration([NotNull] Java9Parser.MethodDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodModifier([NotNull] Java9Parser.MethodModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodModifier([NotNull] Java9Parser.MethodModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodHeader([NotNull] Java9Parser.MethodHeaderContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodHeader([NotNull] Java9Parser.MethodHeaderContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterResult([NotNull] Java9Parser.ResultContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitResult([NotNull] Java9Parser.ResultContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodDeclarator([NotNull] Java9Parser.MethodDeclaratorContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodDeclarator([NotNull] Java9Parser.MethodDeclaratorContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterFormalParameterList([NotNull] Java9Parser.FormalParameterListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitFormalParameterList([NotNull] Java9Parser.FormalParameterListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterFormalParameters([NotNull] Java9Parser.FormalParametersContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitFormalParameters([NotNull] Java9Parser.FormalParametersContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterFormalParameter([NotNull] Java9Parser.FormalParameterContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitFormalParameter([NotNull] Java9Parser.FormalParameterContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterVariableModifier([NotNull] Java9Parser.VariableModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitVariableModifier([NotNull] Java9Parser.VariableModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterLastFormalParameter([NotNull] Java9Parser.LastFormalParameterContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitLastFormalParameter([NotNull] Java9Parser.LastFormalParameterContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterReceiverParameter([NotNull] Java9Parser.ReceiverParameterContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitReceiverParameter([NotNull] Java9Parser.ReceiverParameterContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterThrows_([NotNull] Java9Parser.Throws_Context context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitThrows_([NotNull] Java9Parser.Throws_Context context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterExceptionTypeList([NotNull] Java9Parser.ExceptionTypeListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitExceptionTypeList([NotNull] Java9Parser.ExceptionTypeListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterExceptionType([NotNull] Java9Parser.ExceptionTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitExceptionType([NotNull] Java9Parser.ExceptionTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodBody([NotNull] Java9Parser.MethodBodyContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodBody([NotNull] Java9Parser.MethodBodyContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInstanceInitializer([NotNull] Java9Parser.InstanceInitializerContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInstanceInitializer([NotNull] Java9Parser.InstanceInitializerContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterStaticInitializer([NotNull] Java9Parser.StaticInitializerContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitStaticInitializer([NotNull] Java9Parser.StaticInitializerContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterConstructorDeclaration([NotNull] Java9Parser.ConstructorDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitConstructorDeclaration([NotNull] Java9Parser.ConstructorDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterConstructorModifier([NotNull] Java9Parser.ConstructorModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitConstructorModifier([NotNull] Java9Parser.ConstructorModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterConstructorDeclarator([NotNull] Java9Parser.ConstructorDeclaratorContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitConstructorDeclarator([NotNull] Java9Parser.ConstructorDeclaratorContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSimpleTypeName([NotNull] Java9Parser.SimpleTypeNameContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSimpleTypeName([NotNull] Java9Parser.SimpleTypeNameContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterConstructorBody([NotNull] Java9Parser.ConstructorBodyContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitConstructorBody([NotNull] Java9Parser.ConstructorBodyContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterExplicitConstructorInvocation([NotNull] Java9Parser.ExplicitConstructorInvocationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitExplicitConstructorInvocation([NotNull] Java9Parser.ExplicitConstructorInvocationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterEnumDeclaration([NotNull] Java9Parser.EnumDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitEnumDeclaration([NotNull] Java9Parser.EnumDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterEnumBody([NotNull] Java9Parser.EnumBodyContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitEnumBody([NotNull] Java9Parser.EnumBodyContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterEnumConstantList([NotNull] Java9Parser.EnumConstantListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitEnumConstantList([NotNull] Java9Parser.EnumConstantListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterEnumConstant([NotNull] Java9Parser.EnumConstantContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitEnumConstant([NotNull] Java9Parser.EnumConstantContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterEnumConstantModifier([NotNull] Java9Parser.EnumConstantModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitEnumConstantModifier([NotNull] Java9Parser.EnumConstantModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterEnumBodyDeclarations([NotNull] Java9Parser.EnumBodyDeclarationsContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitEnumBodyDeclarations([NotNull] Java9Parser.EnumBodyDeclarationsContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInterfaceDeclaration([NotNull] Java9Parser.InterfaceDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInterfaceDeclaration([NotNull] Java9Parser.InterfaceDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterNormalInterfaceDeclaration([NotNull] Java9Parser.NormalInterfaceDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitNormalInterfaceDeclaration([NotNull] Java9Parser.NormalInterfaceDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInterfaceModifier([NotNull] Java9Parser.InterfaceModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInterfaceModifier([NotNull] Java9Parser.InterfaceModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterExtendsInterfaces([NotNull] Java9Parser.ExtendsInterfacesContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitExtendsInterfaces([NotNull] Java9Parser.ExtendsInterfacesContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInterfaceBody([NotNull] Java9Parser.InterfaceBodyContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInterfaceBody([NotNull] Java9Parser.InterfaceBodyContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInterfaceMemberDeclaration([NotNull] Java9Parser.InterfaceMemberDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInterfaceMemberDeclaration([NotNull] Java9Parser.InterfaceMemberDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterConstantDeclaration([NotNull] Java9Parser.ConstantDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitConstantDeclaration([NotNull] Java9Parser.ConstantDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterConstantModifier([NotNull] Java9Parser.ConstantModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitConstantModifier([NotNull] Java9Parser.ConstantModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInterfaceMethodDeclaration([NotNull] Java9Parser.InterfaceMethodDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInterfaceMethodDeclaration([NotNull] Java9Parser.InterfaceMethodDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInterfaceMethodModifier([NotNull] Java9Parser.InterfaceMethodModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInterfaceMethodModifier([NotNull] Java9Parser.InterfaceMethodModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAnnotationTypeDeclaration([NotNull] Java9Parser.AnnotationTypeDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAnnotationTypeDeclaration([NotNull] Java9Parser.AnnotationTypeDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAnnotationTypeBody([NotNull] Java9Parser.AnnotationTypeBodyContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAnnotationTypeBody([NotNull] Java9Parser.AnnotationTypeBodyContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAnnotationTypeMemberDeclaration([NotNull] Java9Parser.AnnotationTypeMemberDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAnnotationTypeMemberDeclaration([NotNull] Java9Parser.AnnotationTypeMemberDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAnnotationTypeElementDeclaration([NotNull] Java9Parser.AnnotationTypeElementDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAnnotationTypeElementDeclaration([NotNull] Java9Parser.AnnotationTypeElementDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAnnotationTypeElementModifier([NotNull] Java9Parser.AnnotationTypeElementModifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAnnotationTypeElementModifier([NotNull] Java9Parser.AnnotationTypeElementModifierContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterDefaultValue([NotNull] Java9Parser.DefaultValueContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitDefaultValue([NotNull] Java9Parser.DefaultValueContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAnnotation([NotNull] Java9Parser.AnnotationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAnnotation([NotNull] Java9Parser.AnnotationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterNormalAnnotation([NotNull] Java9Parser.NormalAnnotationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitNormalAnnotation([NotNull] Java9Parser.NormalAnnotationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterElementValuePairList([NotNull] Java9Parser.ElementValuePairListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitElementValuePairList([NotNull] Java9Parser.ElementValuePairListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterElementValuePair([NotNull] Java9Parser.ElementValuePairContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitElementValuePair([NotNull] Java9Parser.ElementValuePairContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterElementValue([NotNull] Java9Parser.ElementValueContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitElementValue([NotNull] Java9Parser.ElementValueContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterElementValueArrayInitializer([NotNull] Java9Parser.ElementValueArrayInitializerContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitElementValueArrayInitializer([NotNull] Java9Parser.ElementValueArrayInitializerContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterElementValueList([NotNull] Java9Parser.ElementValueListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitElementValueList([NotNull] Java9Parser.ElementValueListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMarkerAnnotation([NotNull] Java9Parser.MarkerAnnotationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMarkerAnnotation([NotNull] Java9Parser.MarkerAnnotationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSingleElementAnnotation([NotNull] Java9Parser.SingleElementAnnotationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSingleElementAnnotation([NotNull] Java9Parser.SingleElementAnnotationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterArrayInitializer([NotNull] Java9Parser.ArrayInitializerContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitArrayInitializer([NotNull] Java9Parser.ArrayInitializerContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterVariableInitializerList([NotNull] Java9Parser.VariableInitializerListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitVariableInitializerList([NotNull] Java9Parser.VariableInitializerListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterBlock([NotNull] Java9Parser.BlockContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitBlock([NotNull] Java9Parser.BlockContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterBlockStatements([NotNull] Java9Parser.BlockStatementsContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitBlockStatements([NotNull] Java9Parser.BlockStatementsContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterBlockStatement([NotNull] Java9Parser.BlockStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitBlockStatement([NotNull] Java9Parser.BlockStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterLocalVariableDeclarationStatement([NotNull] Java9Parser.LocalVariableDeclarationStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitLocalVariableDeclarationStatement([NotNull] Java9Parser.LocalVariableDeclarationStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterLocalVariableDeclaration([NotNull] Java9Parser.LocalVariableDeclarationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitLocalVariableDeclaration([NotNull] Java9Parser.LocalVariableDeclarationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterStatement([NotNull] Java9Parser.StatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitStatement([NotNull] Java9Parser.StatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterStatementNoShortIf([NotNull] Java9Parser.StatementNoShortIfContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitStatementNoShortIf([NotNull] Java9Parser.StatementNoShortIfContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterStatementWithoutTrailingSubstatement([NotNull] Java9Parser.StatementWithoutTrailingSubstatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitStatementWithoutTrailingSubstatement([NotNull] Java9Parser.StatementWithoutTrailingSubstatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterEmptyStatement([NotNull] Java9Parser.EmptyStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitEmptyStatement([NotNull] Java9Parser.EmptyStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterLabeledStatement([NotNull] Java9Parser.LabeledStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitLabeledStatement([NotNull] Java9Parser.LabeledStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterLabeledStatementNoShortIf([NotNull] Java9Parser.LabeledStatementNoShortIfContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitLabeledStatementNoShortIf([NotNull] Java9Parser.LabeledStatementNoShortIfContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterExpressionStatement([NotNull] Java9Parser.ExpressionStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitExpressionStatement([NotNull] Java9Parser.ExpressionStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterStatementExpression([NotNull] Java9Parser.StatementExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitStatementExpression([NotNull] Java9Parser.StatementExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterIfThenStatement([NotNull] Java9Parser.IfThenStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitIfThenStatement([NotNull] Java9Parser.IfThenStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterIfThenElseStatement([NotNull] Java9Parser.IfThenElseStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitIfThenElseStatement([NotNull] Java9Parser.IfThenElseStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterIfThenElseStatementNoShortIf([NotNull] Java9Parser.IfThenElseStatementNoShortIfContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitIfThenElseStatementNoShortIf([NotNull] Java9Parser.IfThenElseStatementNoShortIfContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAssertStatement([NotNull] Java9Parser.AssertStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAssertStatement([NotNull] Java9Parser.AssertStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSwitchStatement([NotNull] Java9Parser.SwitchStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSwitchStatement([NotNull] Java9Parser.SwitchStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSwitchBlock([NotNull] Java9Parser.SwitchBlockContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSwitchBlock([NotNull] Java9Parser.SwitchBlockContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSwitchBlockStatementGroup([NotNull] Java9Parser.SwitchBlockStatementGroupContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSwitchBlockStatementGroup([NotNull] Java9Parser.SwitchBlockStatementGroupContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSwitchLabels([NotNull] Java9Parser.SwitchLabelsContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSwitchLabels([NotNull] Java9Parser.SwitchLabelsContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSwitchLabel([NotNull] Java9Parser.SwitchLabelContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSwitchLabel([NotNull] Java9Parser.SwitchLabelContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterEnumConstantName([NotNull] Java9Parser.EnumConstantNameContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitEnumConstantName([NotNull] Java9Parser.EnumConstantNameContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterWhileStatement([NotNull] Java9Parser.WhileStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitWhileStatement([NotNull] Java9Parser.WhileStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterWhileStatementNoShortIf([NotNull] Java9Parser.WhileStatementNoShortIfContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitWhileStatementNoShortIf([NotNull] Java9Parser.WhileStatementNoShortIfContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterDoStatement([NotNull] Java9Parser.DoStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitDoStatement([NotNull] Java9Parser.DoStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterForStatement([NotNull] Java9Parser.ForStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitForStatement([NotNull] Java9Parser.ForStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterForStatementNoShortIf([NotNull] Java9Parser.ForStatementNoShortIfContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitForStatementNoShortIf([NotNull] Java9Parser.ForStatementNoShortIfContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterBasicForStatement([NotNull] Java9Parser.BasicForStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitBasicForStatement([NotNull] Java9Parser.BasicForStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterBasicForStatementNoShortIf([NotNull] Java9Parser.BasicForStatementNoShortIfContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitBasicForStatementNoShortIf([NotNull] Java9Parser.BasicForStatementNoShortIfContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterForInit([NotNull] Java9Parser.ForInitContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitForInit([NotNull] Java9Parser.ForInitContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterForUpdate([NotNull] Java9Parser.ForUpdateContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitForUpdate([NotNull] Java9Parser.ForUpdateContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterStatementExpressionList([NotNull] Java9Parser.StatementExpressionListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitStatementExpressionList([NotNull] Java9Parser.StatementExpressionListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterEnhancedForStatement([NotNull] Java9Parser.EnhancedForStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitEnhancedForStatement([NotNull] Java9Parser.EnhancedForStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterEnhancedForStatementNoShortIf([NotNull] Java9Parser.EnhancedForStatementNoShortIfContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitEnhancedForStatementNoShortIf([NotNull] Java9Parser.EnhancedForStatementNoShortIfContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterBreakStatement([NotNull] Java9Parser.BreakStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitBreakStatement([NotNull] Java9Parser.BreakStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterContinueStatement([NotNull] Java9Parser.ContinueStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitContinueStatement([NotNull] Java9Parser.ContinueStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterReturnStatement([NotNull] Java9Parser.ReturnStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitReturnStatement([NotNull] Java9Parser.ReturnStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterThrowStatement([NotNull] Java9Parser.ThrowStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitThrowStatement([NotNull] Java9Parser.ThrowStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterSynchronizedStatement([NotNull] Java9Parser.SynchronizedStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitSynchronizedStatement([NotNull] Java9Parser.SynchronizedStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTryStatement([NotNull] Java9Parser.TryStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTryStatement([NotNull] Java9Parser.TryStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterCatches([NotNull] Java9Parser.CatchesContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitCatches([NotNull] Java9Parser.CatchesContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterCatchClause([NotNull] Java9Parser.CatchClauseContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitCatchClause([NotNull] Java9Parser.CatchClauseContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterCatchFormalParameter([NotNull] Java9Parser.CatchFormalParameterContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitCatchFormalParameter([NotNull] Java9Parser.CatchFormalParameterContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterCatchType([NotNull] Java9Parser.CatchTypeContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitCatchType([NotNull] Java9Parser.CatchTypeContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterFinally_([NotNull] Java9Parser.Finally_Context context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitFinally_([NotNull] Java9Parser.Finally_Context context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTryWithResourcesStatement([NotNull] Java9Parser.TryWithResourcesStatementContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTryWithResourcesStatement([NotNull] Java9Parser.TryWithResourcesStatementContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterResourceSpecification([NotNull] Java9Parser.ResourceSpecificationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitResourceSpecification([NotNull] Java9Parser.ResourceSpecificationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterResourceList([NotNull] Java9Parser.ResourceListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitResourceList([NotNull] Java9Parser.ResourceListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterResource([NotNull] Java9Parser.ResourceContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitResource([NotNull] Java9Parser.ResourceContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterVariableAccess([NotNull] Java9Parser.VariableAccessContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitVariableAccess([NotNull] Java9Parser.VariableAccessContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPrimary([NotNull] Java9Parser.PrimaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPrimary([NotNull] Java9Parser.PrimaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPrimaryNoNewArray([NotNull] Java9Parser.PrimaryNoNewArrayContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPrimaryNoNewArray([NotNull] Java9Parser.PrimaryNoNewArrayContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPrimaryNoNewArray_lf_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lf_arrayAccessContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPrimaryNoNewArray_lf_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lf_arrayAccessContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPrimaryNoNewArray_lfno_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lfno_arrayAccessContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPrimaryNoNewArray_lfno_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lfno_arrayAccessContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPrimaryNoNewArray_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPrimaryNoNewArray_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPrimaryNoNewArray_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPrimaryNoNewArray_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassLiteral([NotNull] Java9Parser.ClassLiteralContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassLiteral([NotNull] Java9Parser.ClassLiteralContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassInstanceCreationExpression([NotNull] Java9Parser.ClassInstanceCreationExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassInstanceCreationExpression([NotNull] Java9Parser.ClassInstanceCreationExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassInstanceCreationExpression_lf_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lf_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassInstanceCreationExpression_lf_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lf_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterClassInstanceCreationExpression_lfno_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lfno_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitClassInstanceCreationExpression_lfno_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lfno_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterTypeArgumentsOrDiamond([NotNull] Java9Parser.TypeArgumentsOrDiamondContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitTypeArgumentsOrDiamond([NotNull] Java9Parser.TypeArgumentsOrDiamondContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterFieldAccess([NotNull] Java9Parser.FieldAccessContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitFieldAccess([NotNull] Java9Parser.FieldAccessContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterFieldAccess_lf_primary([NotNull] Java9Parser.FieldAccess_lf_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitFieldAccess_lf_primary([NotNull] Java9Parser.FieldAccess_lf_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterFieldAccess_lfno_primary([NotNull] Java9Parser.FieldAccess_lfno_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitFieldAccess_lfno_primary([NotNull] Java9Parser.FieldAccess_lfno_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterArrayAccess([NotNull] Java9Parser.ArrayAccessContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitArrayAccess([NotNull] Java9Parser.ArrayAccessContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterArrayAccess_lf_primary([NotNull] Java9Parser.ArrayAccess_lf_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitArrayAccess_lf_primary([NotNull] Java9Parser.ArrayAccess_lf_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterArrayAccess_lfno_primary([NotNull] Java9Parser.ArrayAccess_lfno_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitArrayAccess_lfno_primary([NotNull] Java9Parser.ArrayAccess_lfno_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodInvocation([NotNull] Java9Parser.MethodInvocationContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodInvocation([NotNull] Java9Parser.MethodInvocationContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodInvocation_lf_primary([NotNull] Java9Parser.MethodInvocation_lf_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodInvocation_lf_primary([NotNull] Java9Parser.MethodInvocation_lf_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodInvocation_lfno_primary([NotNull] Java9Parser.MethodInvocation_lfno_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodInvocation_lfno_primary([NotNull] Java9Parser.MethodInvocation_lfno_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterArgumentList([NotNull] Java9Parser.ArgumentListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitArgumentList([NotNull] Java9Parser.ArgumentListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodReference([NotNull] Java9Parser.MethodReferenceContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodReference([NotNull] Java9Parser.MethodReferenceContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodReference_lf_primary([NotNull] Java9Parser.MethodReference_lf_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodReference_lf_primary([NotNull] Java9Parser.MethodReference_lf_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMethodReference_lfno_primary([NotNull] Java9Parser.MethodReference_lfno_primaryContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMethodReference_lfno_primary([NotNull] Java9Parser.MethodReference_lfno_primaryContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterArrayCreationExpression([NotNull] Java9Parser.ArrayCreationExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitArrayCreationExpression([NotNull] Java9Parser.ArrayCreationExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterDimExprs([NotNull] Java9Parser.DimExprsContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitDimExprs([NotNull] Java9Parser.DimExprsContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterDimExpr([NotNull] Java9Parser.DimExprContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitDimExpr([NotNull] Java9Parser.DimExprContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterConstantExpression([NotNull] Java9Parser.ConstantExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitConstantExpression([NotNull] Java9Parser.ConstantExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterExpression([NotNull] Java9Parser.ExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitExpression([NotNull] Java9Parser.ExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterLambdaExpression([NotNull] Java9Parser.LambdaExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitLambdaExpression([NotNull] Java9Parser.LambdaExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterLambdaParameters([NotNull] Java9Parser.LambdaParametersContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitLambdaParameters([NotNull] Java9Parser.LambdaParametersContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInferredFormalParameterList([NotNull] Java9Parser.InferredFormalParameterListContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInferredFormalParameterList([NotNull] Java9Parser.InferredFormalParameterListContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterLambdaBody([NotNull] Java9Parser.LambdaBodyContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitLambdaBody([NotNull] Java9Parser.LambdaBodyContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAssignmentExpression([NotNull] Java9Parser.AssignmentExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAssignmentExpression([NotNull] Java9Parser.AssignmentExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAssignment([NotNull] Java9Parser.AssignmentContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAssignment([NotNull] Java9Parser.AssignmentContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterLeftHandSide([NotNull] Java9Parser.LeftHandSideContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitLeftHandSide([NotNull] Java9Parser.LeftHandSideContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAssignmentOperator([NotNull] Java9Parser.AssignmentOperatorContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAssignmentOperator([NotNull] Java9Parser.AssignmentOperatorContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterConditionalExpression([NotNull] Java9Parser.ConditionalExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitConditionalExpression([NotNull] Java9Parser.ConditionalExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterConditionalOrExpression([NotNull] Java9Parser.ConditionalOrExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitConditionalOrExpression([NotNull] Java9Parser.ConditionalOrExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterConditionalAndExpression([NotNull] Java9Parser.ConditionalAndExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitConditionalAndExpression([NotNull] Java9Parser.ConditionalAndExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterInclusiveOrExpression([NotNull] Java9Parser.InclusiveOrExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitInclusiveOrExpression([NotNull] Java9Parser.InclusiveOrExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterExclusiveOrExpression([NotNull] Java9Parser.ExclusiveOrExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitExclusiveOrExpression([NotNull] Java9Parser.ExclusiveOrExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAndExpression([NotNull] Java9Parser.AndExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAndExpression([NotNull] Java9Parser.AndExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterEqualityExpression([NotNull] Java9Parser.EqualityExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitEqualityExpression([NotNull] Java9Parser.EqualityExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterRelationalExpression([NotNull] Java9Parser.RelationalExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitRelationalExpression([NotNull] Java9Parser.RelationalExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterShiftExpression([NotNull] Java9Parser.ShiftExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitShiftExpression([NotNull] Java9Parser.ShiftExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterAdditiveExpression([NotNull] Java9Parser.AdditiveExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitAdditiveExpression([NotNull] Java9Parser.AdditiveExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterMultiplicativeExpression([NotNull] Java9Parser.MultiplicativeExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitMultiplicativeExpression([NotNull] Java9Parser.MultiplicativeExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnaryExpression([NotNull] Java9Parser.UnaryExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnaryExpression([NotNull] Java9Parser.UnaryExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPreIncrementExpression([NotNull] Java9Parser.PreIncrementExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPreIncrementExpression([NotNull] Java9Parser.PreIncrementExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPreDecrementExpression([NotNull] Java9Parser.PreDecrementExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPreDecrementExpression([NotNull] Java9Parser.PreDecrementExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterUnaryExpressionNotPlusMinus([NotNull] Java9Parser.UnaryExpressionNotPlusMinusContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitUnaryExpressionNotPlusMinus([NotNull] Java9Parser.UnaryExpressionNotPlusMinusContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPostfixExpression([NotNull] Java9Parser.PostfixExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPostfixExpression([NotNull] Java9Parser.PostfixExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPostIncrementExpression([NotNull] Java9Parser.PostIncrementExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPostIncrementExpression([NotNull] Java9Parser.PostIncrementExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPostIncrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostIncrementExpression_lf_postfixExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPostIncrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostIncrementExpression_lf_postfixExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPostDecrementExpression([NotNull] Java9Parser.PostDecrementExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPostDecrementExpression([NotNull] Java9Parser.PostDecrementExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterPostDecrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostDecrementExpression_lf_postfixExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitPostDecrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostDecrementExpression_lf_postfixExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterCastExpression([NotNull] Java9Parser.CastExpressionContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitCastExpression([NotNull] Java9Parser.CastExpressionContext context) { } + /// + /// Enter a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void EnterIdentifier([NotNull] Java9Parser.IdentifierContext context) { } + /// + /// Exit a parse tree produced by . + /// The default implementation does nothing. + /// + /// The parse tree. + public virtual void ExitIdentifier([NotNull] Java9Parser.IdentifierContext context) { } + + /// + /// The default implementation does nothing. + public virtual void EnterEveryRule([NotNull] ParserRuleContext context) { } + /// + /// The default implementation does nothing. + public virtual void ExitEveryRule([NotNull] ParserRuleContext context) { } + /// + /// The default implementation does nothing. + public virtual void VisitTerminal([NotNull] ITerminalNode node) { } + /// + /// The default implementation does nothing. + public virtual void VisitErrorNode([NotNull] IErrorNode node) { } +} diff --git a/Tests.Runtime.Standard/Java9/Java9ParserBaseVisitor.cs b/Tests.Runtime.Standard/Java9/Java9ParserBaseVisitor.cs new file mode 100644 index 0000000..69e5ebd --- /dev/null +++ b/Tests.Runtime.Standard/Java9/Java9ParserBaseVisitor.cs @@ -0,0 +1,2486 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// ANTLR Version: 4.7.2 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +// Generated from C:\Users\Spitz\source\repos\AntlrBug_40\AntlrConsole3\Java9Parser.g4 by ANTLR 4.7.2 + +// Unreachable code detected +#pragma warning disable 0162 +// The variable '...' is assigned but its value is never used +#pragma warning disable 0219 +// Missing XML comment for publicly visible type or member '...' +#pragma warning disable 1591 +// Ambiguous reference in cref attribute +#pragma warning disable 419 + +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; +using IToken = Antlr4.Runtime.IToken; +using ParserRuleContext = Antlr4.Runtime.ParserRuleContext; + +/// +/// This class provides an empty implementation of , +/// which can be extended to create a visitor which only needs to handle a subset +/// of the available methods. +/// +/// The return type of the visit operation. +[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.7.2")] +[System.CLSCompliant(false)] +public partial class Java9ParserBaseVisitor : AbstractParseTreeVisitor, IJava9ParserVisitor { + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitLiteral([NotNull] Java9Parser.LiteralContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPrimitiveType([NotNull] Java9Parser.PrimitiveTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitNumericType([NotNull] Java9Parser.NumericTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitIntegralType([NotNull] Java9Parser.IntegralTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitFloatingPointType([NotNull] Java9Parser.FloatingPointTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitReferenceType([NotNull] Java9Parser.ReferenceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassOrInterfaceType([NotNull] Java9Parser.ClassOrInterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassType([NotNull] Java9Parser.ClassTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassType_lf_classOrInterfaceType([NotNull] Java9Parser.ClassType_lf_classOrInterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassType_lfno_classOrInterfaceType([NotNull] Java9Parser.ClassType_lfno_classOrInterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInterfaceType([NotNull] Java9Parser.InterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInterfaceType_lf_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lf_classOrInterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInterfaceType_lfno_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lfno_classOrInterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeVariable([NotNull] Java9Parser.TypeVariableContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitArrayType([NotNull] Java9Parser.ArrayTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitDims([NotNull] Java9Parser.DimsContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeParameter([NotNull] Java9Parser.TypeParameterContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeParameterModifier([NotNull] Java9Parser.TypeParameterModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeBound([NotNull] Java9Parser.TypeBoundContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAdditionalBound([NotNull] Java9Parser.AdditionalBoundContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeArguments([NotNull] Java9Parser.TypeArgumentsContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeArgumentList([NotNull] Java9Parser.TypeArgumentListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeArgument([NotNull] Java9Parser.TypeArgumentContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitWildcard([NotNull] Java9Parser.WildcardContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitWildcardBounds([NotNull] Java9Parser.WildcardBoundsContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitModuleName([NotNull] Java9Parser.ModuleNameContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPackageName([NotNull] Java9Parser.PackageNameContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeName([NotNull] Java9Parser.TypeNameContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPackageOrTypeName([NotNull] Java9Parser.PackageOrTypeNameContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitExpressionName([NotNull] Java9Parser.ExpressionNameContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodName([NotNull] Java9Parser.MethodNameContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAmbiguousName([NotNull] Java9Parser.AmbiguousNameContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitCompilationUnit([NotNull] Java9Parser.CompilationUnitContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitOrdinaryCompilation([NotNull] Java9Parser.OrdinaryCompilationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitModularCompilation([NotNull] Java9Parser.ModularCompilationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPackageDeclaration([NotNull] Java9Parser.PackageDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPackageModifier([NotNull] Java9Parser.PackageModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitImportDeclaration([NotNull] Java9Parser.ImportDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSingleTypeImportDeclaration([NotNull] Java9Parser.SingleTypeImportDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeImportOnDemandDeclaration([NotNull] Java9Parser.TypeImportOnDemandDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSingleStaticImportDeclaration([NotNull] Java9Parser.SingleStaticImportDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitStaticImportOnDemandDeclaration([NotNull] Java9Parser.StaticImportOnDemandDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeDeclaration([NotNull] Java9Parser.TypeDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitModuleDeclaration([NotNull] Java9Parser.ModuleDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitModuleDirective([NotNull] Java9Parser.ModuleDirectiveContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitRequiresModifier([NotNull] Java9Parser.RequiresModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassDeclaration([NotNull] Java9Parser.ClassDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitNormalClassDeclaration([NotNull] Java9Parser.NormalClassDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassModifier([NotNull] Java9Parser.ClassModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeParameters([NotNull] Java9Parser.TypeParametersContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeParameterList([NotNull] Java9Parser.TypeParameterListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSuperclass([NotNull] Java9Parser.SuperclassContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSuperinterfaces([NotNull] Java9Parser.SuperinterfacesContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInterfaceTypeList([NotNull] Java9Parser.InterfaceTypeListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassBody([NotNull] Java9Parser.ClassBodyContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassBodyDeclaration([NotNull] Java9Parser.ClassBodyDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassMemberDeclaration([NotNull] Java9Parser.ClassMemberDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitFieldDeclaration([NotNull] Java9Parser.FieldDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitFieldModifier([NotNull] Java9Parser.FieldModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitVariableDeclaratorList([NotNull] Java9Parser.VariableDeclaratorListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitVariableDeclarator([NotNull] Java9Parser.VariableDeclaratorContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitVariableDeclaratorId([NotNull] Java9Parser.VariableDeclaratorIdContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitVariableInitializer([NotNull] Java9Parser.VariableInitializerContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannType([NotNull] Java9Parser.UnannTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannPrimitiveType([NotNull] Java9Parser.UnannPrimitiveTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannReferenceType([NotNull] Java9Parser.UnannReferenceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannClassOrInterfaceType([NotNull] Java9Parser.UnannClassOrInterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannClassType([NotNull] Java9Parser.UnannClassTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannClassType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannClassType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannInterfaceType([NotNull] Java9Parser.UnannInterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannInterfaceType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannInterfaceType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannTypeVariable([NotNull] Java9Parser.UnannTypeVariableContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnannArrayType([NotNull] Java9Parser.UnannArrayTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodDeclaration([NotNull] Java9Parser.MethodDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodModifier([NotNull] Java9Parser.MethodModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodHeader([NotNull] Java9Parser.MethodHeaderContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitResult([NotNull] Java9Parser.ResultContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodDeclarator([NotNull] Java9Parser.MethodDeclaratorContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitFormalParameterList([NotNull] Java9Parser.FormalParameterListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitFormalParameters([NotNull] Java9Parser.FormalParametersContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitFormalParameter([NotNull] Java9Parser.FormalParameterContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitVariableModifier([NotNull] Java9Parser.VariableModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitLastFormalParameter([NotNull] Java9Parser.LastFormalParameterContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitReceiverParameter([NotNull] Java9Parser.ReceiverParameterContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitThrows_([NotNull] Java9Parser.Throws_Context context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitExceptionTypeList([NotNull] Java9Parser.ExceptionTypeListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitExceptionType([NotNull] Java9Parser.ExceptionTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodBody([NotNull] Java9Parser.MethodBodyContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInstanceInitializer([NotNull] Java9Parser.InstanceInitializerContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitStaticInitializer([NotNull] Java9Parser.StaticInitializerContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitConstructorDeclaration([NotNull] Java9Parser.ConstructorDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitConstructorModifier([NotNull] Java9Parser.ConstructorModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitConstructorDeclarator([NotNull] Java9Parser.ConstructorDeclaratorContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSimpleTypeName([NotNull] Java9Parser.SimpleTypeNameContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitConstructorBody([NotNull] Java9Parser.ConstructorBodyContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitExplicitConstructorInvocation([NotNull] Java9Parser.ExplicitConstructorInvocationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitEnumDeclaration([NotNull] Java9Parser.EnumDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitEnumBody([NotNull] Java9Parser.EnumBodyContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitEnumConstantList([NotNull] Java9Parser.EnumConstantListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitEnumConstant([NotNull] Java9Parser.EnumConstantContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitEnumConstantModifier([NotNull] Java9Parser.EnumConstantModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitEnumBodyDeclarations([NotNull] Java9Parser.EnumBodyDeclarationsContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInterfaceDeclaration([NotNull] Java9Parser.InterfaceDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitNormalInterfaceDeclaration([NotNull] Java9Parser.NormalInterfaceDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInterfaceModifier([NotNull] Java9Parser.InterfaceModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitExtendsInterfaces([NotNull] Java9Parser.ExtendsInterfacesContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInterfaceBody([NotNull] Java9Parser.InterfaceBodyContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInterfaceMemberDeclaration([NotNull] Java9Parser.InterfaceMemberDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitConstantDeclaration([NotNull] Java9Parser.ConstantDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitConstantModifier([NotNull] Java9Parser.ConstantModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInterfaceMethodDeclaration([NotNull] Java9Parser.InterfaceMethodDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInterfaceMethodModifier([NotNull] Java9Parser.InterfaceMethodModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAnnotationTypeDeclaration([NotNull] Java9Parser.AnnotationTypeDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAnnotationTypeBody([NotNull] Java9Parser.AnnotationTypeBodyContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAnnotationTypeMemberDeclaration([NotNull] Java9Parser.AnnotationTypeMemberDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAnnotationTypeElementDeclaration([NotNull] Java9Parser.AnnotationTypeElementDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAnnotationTypeElementModifier([NotNull] Java9Parser.AnnotationTypeElementModifierContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitDefaultValue([NotNull] Java9Parser.DefaultValueContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAnnotation([NotNull] Java9Parser.AnnotationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitNormalAnnotation([NotNull] Java9Parser.NormalAnnotationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitElementValuePairList([NotNull] Java9Parser.ElementValuePairListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitElementValuePair([NotNull] Java9Parser.ElementValuePairContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitElementValue([NotNull] Java9Parser.ElementValueContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitElementValueArrayInitializer([NotNull] Java9Parser.ElementValueArrayInitializerContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitElementValueList([NotNull] Java9Parser.ElementValueListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMarkerAnnotation([NotNull] Java9Parser.MarkerAnnotationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSingleElementAnnotation([NotNull] Java9Parser.SingleElementAnnotationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitArrayInitializer([NotNull] Java9Parser.ArrayInitializerContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitVariableInitializerList([NotNull] Java9Parser.VariableInitializerListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitBlock([NotNull] Java9Parser.BlockContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitBlockStatements([NotNull] Java9Parser.BlockStatementsContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitBlockStatement([NotNull] Java9Parser.BlockStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitLocalVariableDeclarationStatement([NotNull] Java9Parser.LocalVariableDeclarationStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitLocalVariableDeclaration([NotNull] Java9Parser.LocalVariableDeclarationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitStatement([NotNull] Java9Parser.StatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitStatementNoShortIf([NotNull] Java9Parser.StatementNoShortIfContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitStatementWithoutTrailingSubstatement([NotNull] Java9Parser.StatementWithoutTrailingSubstatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitEmptyStatement([NotNull] Java9Parser.EmptyStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitLabeledStatement([NotNull] Java9Parser.LabeledStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitLabeledStatementNoShortIf([NotNull] Java9Parser.LabeledStatementNoShortIfContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitExpressionStatement([NotNull] Java9Parser.ExpressionStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitStatementExpression([NotNull] Java9Parser.StatementExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitIfThenStatement([NotNull] Java9Parser.IfThenStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitIfThenElseStatement([NotNull] Java9Parser.IfThenElseStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitIfThenElseStatementNoShortIf([NotNull] Java9Parser.IfThenElseStatementNoShortIfContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAssertStatement([NotNull] Java9Parser.AssertStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSwitchStatement([NotNull] Java9Parser.SwitchStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSwitchBlock([NotNull] Java9Parser.SwitchBlockContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSwitchBlockStatementGroup([NotNull] Java9Parser.SwitchBlockStatementGroupContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSwitchLabels([NotNull] Java9Parser.SwitchLabelsContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSwitchLabel([NotNull] Java9Parser.SwitchLabelContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitEnumConstantName([NotNull] Java9Parser.EnumConstantNameContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitWhileStatement([NotNull] Java9Parser.WhileStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitWhileStatementNoShortIf([NotNull] Java9Parser.WhileStatementNoShortIfContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitDoStatement([NotNull] Java9Parser.DoStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitForStatement([NotNull] Java9Parser.ForStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitForStatementNoShortIf([NotNull] Java9Parser.ForStatementNoShortIfContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitBasicForStatement([NotNull] Java9Parser.BasicForStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitBasicForStatementNoShortIf([NotNull] Java9Parser.BasicForStatementNoShortIfContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitForInit([NotNull] Java9Parser.ForInitContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitForUpdate([NotNull] Java9Parser.ForUpdateContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitStatementExpressionList([NotNull] Java9Parser.StatementExpressionListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitEnhancedForStatement([NotNull] Java9Parser.EnhancedForStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitEnhancedForStatementNoShortIf([NotNull] Java9Parser.EnhancedForStatementNoShortIfContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitBreakStatement([NotNull] Java9Parser.BreakStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitContinueStatement([NotNull] Java9Parser.ContinueStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitReturnStatement([NotNull] Java9Parser.ReturnStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitThrowStatement([NotNull] Java9Parser.ThrowStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitSynchronizedStatement([NotNull] Java9Parser.SynchronizedStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTryStatement([NotNull] Java9Parser.TryStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitCatches([NotNull] Java9Parser.CatchesContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitCatchClause([NotNull] Java9Parser.CatchClauseContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitCatchFormalParameter([NotNull] Java9Parser.CatchFormalParameterContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitCatchType([NotNull] Java9Parser.CatchTypeContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitFinally_([NotNull] Java9Parser.Finally_Context context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTryWithResourcesStatement([NotNull] Java9Parser.TryWithResourcesStatementContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitResourceSpecification([NotNull] Java9Parser.ResourceSpecificationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitResourceList([NotNull] Java9Parser.ResourceListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitResource([NotNull] Java9Parser.ResourceContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitVariableAccess([NotNull] Java9Parser.VariableAccessContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPrimary([NotNull] Java9Parser.PrimaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPrimaryNoNewArray([NotNull] Java9Parser.PrimaryNoNewArrayContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPrimaryNoNewArray_lf_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lf_arrayAccessContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPrimaryNoNewArray_lfno_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lfno_arrayAccessContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPrimaryNoNewArray_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPrimaryNoNewArray_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassLiteral([NotNull] Java9Parser.ClassLiteralContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassInstanceCreationExpression([NotNull] Java9Parser.ClassInstanceCreationExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassInstanceCreationExpression_lf_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lf_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitClassInstanceCreationExpression_lfno_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lfno_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitTypeArgumentsOrDiamond([NotNull] Java9Parser.TypeArgumentsOrDiamondContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitFieldAccess([NotNull] Java9Parser.FieldAccessContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitFieldAccess_lf_primary([NotNull] Java9Parser.FieldAccess_lf_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitFieldAccess_lfno_primary([NotNull] Java9Parser.FieldAccess_lfno_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitArrayAccess([NotNull] Java9Parser.ArrayAccessContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitArrayAccess_lf_primary([NotNull] Java9Parser.ArrayAccess_lf_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitArrayAccess_lfno_primary([NotNull] Java9Parser.ArrayAccess_lfno_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodInvocation([NotNull] Java9Parser.MethodInvocationContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodInvocation_lf_primary([NotNull] Java9Parser.MethodInvocation_lf_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodInvocation_lfno_primary([NotNull] Java9Parser.MethodInvocation_lfno_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitArgumentList([NotNull] Java9Parser.ArgumentListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodReference([NotNull] Java9Parser.MethodReferenceContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodReference_lf_primary([NotNull] Java9Parser.MethodReference_lf_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodReference_lfno_primary([NotNull] Java9Parser.MethodReference_lfno_primaryContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitArrayCreationExpression([NotNull] Java9Parser.ArrayCreationExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitDimExprs([NotNull] Java9Parser.DimExprsContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitDimExpr([NotNull] Java9Parser.DimExprContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitConstantExpression([NotNull] Java9Parser.ConstantExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitExpression([NotNull] Java9Parser.ExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitLambdaExpression([NotNull] Java9Parser.LambdaExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitLambdaParameters([NotNull] Java9Parser.LambdaParametersContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInferredFormalParameterList([NotNull] Java9Parser.InferredFormalParameterListContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitLambdaBody([NotNull] Java9Parser.LambdaBodyContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAssignmentExpression([NotNull] Java9Parser.AssignmentExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAssignment([NotNull] Java9Parser.AssignmentContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitLeftHandSide([NotNull] Java9Parser.LeftHandSideContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAssignmentOperator([NotNull] Java9Parser.AssignmentOperatorContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitConditionalExpression([NotNull] Java9Parser.ConditionalExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitConditionalOrExpression([NotNull] Java9Parser.ConditionalOrExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitConditionalAndExpression([NotNull] Java9Parser.ConditionalAndExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitInclusiveOrExpression([NotNull] Java9Parser.InclusiveOrExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitExclusiveOrExpression([NotNull] Java9Parser.ExclusiveOrExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAndExpression([NotNull] Java9Parser.AndExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitEqualityExpression([NotNull] Java9Parser.EqualityExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitRelationalExpression([NotNull] Java9Parser.RelationalExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitShiftExpression([NotNull] Java9Parser.ShiftExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAdditiveExpression([NotNull] Java9Parser.AdditiveExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMultiplicativeExpression([NotNull] Java9Parser.MultiplicativeExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnaryExpression([NotNull] Java9Parser.UnaryExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPreIncrementExpression([NotNull] Java9Parser.PreIncrementExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPreDecrementExpression([NotNull] Java9Parser.PreDecrementExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitUnaryExpressionNotPlusMinus([NotNull] Java9Parser.UnaryExpressionNotPlusMinusContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPostfixExpression([NotNull] Java9Parser.PostfixExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPostIncrementExpression([NotNull] Java9Parser.PostIncrementExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPostIncrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostIncrementExpression_lf_postfixExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPostDecrementExpression([NotNull] Java9Parser.PostDecrementExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitPostDecrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostDecrementExpression_lf_postfixExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitCastExpression([NotNull] Java9Parser.CastExpressionContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitIdentifier([NotNull] Java9Parser.IdentifierContext context) { return VisitChildren(context); } +} diff --git a/Tests.Runtime.Standard/Java9/Java9ParserListener.cs b/Tests.Runtime.Standard/Java9/Java9ParserListener.cs new file mode 100644 index 0000000..ac65951 --- /dev/null +++ b/Tests.Runtime.Standard/Java9/Java9ParserListener.cs @@ -0,0 +1,2483 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// ANTLR Version: 4.7.2 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +// Generated from C:\Users\Spitz\source\repos\AntlrBug_40\AntlrConsole3\Java9Parser.g4 by ANTLR 4.7.2 + +// Unreachable code detected +#pragma warning disable 0162 +// The variable '...' is assigned but its value is never used +#pragma warning disable 0219 +// Missing XML comment for publicly visible type or member '...' +#pragma warning disable 1591 +// Ambiguous reference in cref attribute +#pragma warning disable 419 + +using Antlr4.Runtime.Misc; +using IParseTreeListener = Antlr4.Runtime.Tree.IParseTreeListener; +using IToken = Antlr4.Runtime.IToken; + +/// +/// This interface defines a complete listener for a parse tree produced by +/// . +/// +[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.7.2")] +[System.CLSCompliant(false)] +public interface IJava9ParserListener : IParseTreeListener { + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterLiteral([NotNull] Java9Parser.LiteralContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitLiteral([NotNull] Java9Parser.LiteralContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPrimitiveType([NotNull] Java9Parser.PrimitiveTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPrimitiveType([NotNull] Java9Parser.PrimitiveTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterNumericType([NotNull] Java9Parser.NumericTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitNumericType([NotNull] Java9Parser.NumericTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterIntegralType([NotNull] Java9Parser.IntegralTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitIntegralType([NotNull] Java9Parser.IntegralTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterFloatingPointType([NotNull] Java9Parser.FloatingPointTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitFloatingPointType([NotNull] Java9Parser.FloatingPointTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterReferenceType([NotNull] Java9Parser.ReferenceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitReferenceType([NotNull] Java9Parser.ReferenceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassOrInterfaceType([NotNull] Java9Parser.ClassOrInterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassOrInterfaceType([NotNull] Java9Parser.ClassOrInterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassType([NotNull] Java9Parser.ClassTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassType([NotNull] Java9Parser.ClassTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassType_lf_classOrInterfaceType([NotNull] Java9Parser.ClassType_lf_classOrInterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassType_lf_classOrInterfaceType([NotNull] Java9Parser.ClassType_lf_classOrInterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassType_lfno_classOrInterfaceType([NotNull] Java9Parser.ClassType_lfno_classOrInterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassType_lfno_classOrInterfaceType([NotNull] Java9Parser.ClassType_lfno_classOrInterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInterfaceType([NotNull] Java9Parser.InterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInterfaceType([NotNull] Java9Parser.InterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInterfaceType_lf_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lf_classOrInterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInterfaceType_lf_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lf_classOrInterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInterfaceType_lfno_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lfno_classOrInterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInterfaceType_lfno_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lfno_classOrInterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeVariable([NotNull] Java9Parser.TypeVariableContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeVariable([NotNull] Java9Parser.TypeVariableContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterArrayType([NotNull] Java9Parser.ArrayTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitArrayType([NotNull] Java9Parser.ArrayTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterDims([NotNull] Java9Parser.DimsContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitDims([NotNull] Java9Parser.DimsContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeParameter([NotNull] Java9Parser.TypeParameterContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeParameter([NotNull] Java9Parser.TypeParameterContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeParameterModifier([NotNull] Java9Parser.TypeParameterModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeParameterModifier([NotNull] Java9Parser.TypeParameterModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeBound([NotNull] Java9Parser.TypeBoundContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeBound([NotNull] Java9Parser.TypeBoundContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAdditionalBound([NotNull] Java9Parser.AdditionalBoundContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAdditionalBound([NotNull] Java9Parser.AdditionalBoundContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeArguments([NotNull] Java9Parser.TypeArgumentsContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeArguments([NotNull] Java9Parser.TypeArgumentsContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeArgumentList([NotNull] Java9Parser.TypeArgumentListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeArgumentList([NotNull] Java9Parser.TypeArgumentListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeArgument([NotNull] Java9Parser.TypeArgumentContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeArgument([NotNull] Java9Parser.TypeArgumentContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterWildcard([NotNull] Java9Parser.WildcardContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitWildcard([NotNull] Java9Parser.WildcardContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterWildcardBounds([NotNull] Java9Parser.WildcardBoundsContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitWildcardBounds([NotNull] Java9Parser.WildcardBoundsContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterModuleName([NotNull] Java9Parser.ModuleNameContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitModuleName([NotNull] Java9Parser.ModuleNameContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPackageName([NotNull] Java9Parser.PackageNameContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPackageName([NotNull] Java9Parser.PackageNameContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeName([NotNull] Java9Parser.TypeNameContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeName([NotNull] Java9Parser.TypeNameContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPackageOrTypeName([NotNull] Java9Parser.PackageOrTypeNameContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPackageOrTypeName([NotNull] Java9Parser.PackageOrTypeNameContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterExpressionName([NotNull] Java9Parser.ExpressionNameContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitExpressionName([NotNull] Java9Parser.ExpressionNameContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodName([NotNull] Java9Parser.MethodNameContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodName([NotNull] Java9Parser.MethodNameContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAmbiguousName([NotNull] Java9Parser.AmbiguousNameContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAmbiguousName([NotNull] Java9Parser.AmbiguousNameContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterCompilationUnit([NotNull] Java9Parser.CompilationUnitContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitCompilationUnit([NotNull] Java9Parser.CompilationUnitContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterOrdinaryCompilation([NotNull] Java9Parser.OrdinaryCompilationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitOrdinaryCompilation([NotNull] Java9Parser.OrdinaryCompilationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterModularCompilation([NotNull] Java9Parser.ModularCompilationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitModularCompilation([NotNull] Java9Parser.ModularCompilationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPackageDeclaration([NotNull] Java9Parser.PackageDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPackageDeclaration([NotNull] Java9Parser.PackageDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPackageModifier([NotNull] Java9Parser.PackageModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPackageModifier([NotNull] Java9Parser.PackageModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterImportDeclaration([NotNull] Java9Parser.ImportDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitImportDeclaration([NotNull] Java9Parser.ImportDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSingleTypeImportDeclaration([NotNull] Java9Parser.SingleTypeImportDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSingleTypeImportDeclaration([NotNull] Java9Parser.SingleTypeImportDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeImportOnDemandDeclaration([NotNull] Java9Parser.TypeImportOnDemandDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeImportOnDemandDeclaration([NotNull] Java9Parser.TypeImportOnDemandDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSingleStaticImportDeclaration([NotNull] Java9Parser.SingleStaticImportDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSingleStaticImportDeclaration([NotNull] Java9Parser.SingleStaticImportDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterStaticImportOnDemandDeclaration([NotNull] Java9Parser.StaticImportOnDemandDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitStaticImportOnDemandDeclaration([NotNull] Java9Parser.StaticImportOnDemandDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeDeclaration([NotNull] Java9Parser.TypeDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeDeclaration([NotNull] Java9Parser.TypeDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterModuleDeclaration([NotNull] Java9Parser.ModuleDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitModuleDeclaration([NotNull] Java9Parser.ModuleDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterModuleDirective([NotNull] Java9Parser.ModuleDirectiveContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitModuleDirective([NotNull] Java9Parser.ModuleDirectiveContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterRequiresModifier([NotNull] Java9Parser.RequiresModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitRequiresModifier([NotNull] Java9Parser.RequiresModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassDeclaration([NotNull] Java9Parser.ClassDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassDeclaration([NotNull] Java9Parser.ClassDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterNormalClassDeclaration([NotNull] Java9Parser.NormalClassDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitNormalClassDeclaration([NotNull] Java9Parser.NormalClassDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassModifier([NotNull] Java9Parser.ClassModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassModifier([NotNull] Java9Parser.ClassModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeParameters([NotNull] Java9Parser.TypeParametersContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeParameters([NotNull] Java9Parser.TypeParametersContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeParameterList([NotNull] Java9Parser.TypeParameterListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeParameterList([NotNull] Java9Parser.TypeParameterListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSuperclass([NotNull] Java9Parser.SuperclassContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSuperclass([NotNull] Java9Parser.SuperclassContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSuperinterfaces([NotNull] Java9Parser.SuperinterfacesContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSuperinterfaces([NotNull] Java9Parser.SuperinterfacesContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInterfaceTypeList([NotNull] Java9Parser.InterfaceTypeListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInterfaceTypeList([NotNull] Java9Parser.InterfaceTypeListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassBody([NotNull] Java9Parser.ClassBodyContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassBody([NotNull] Java9Parser.ClassBodyContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassBodyDeclaration([NotNull] Java9Parser.ClassBodyDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassBodyDeclaration([NotNull] Java9Parser.ClassBodyDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassMemberDeclaration([NotNull] Java9Parser.ClassMemberDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassMemberDeclaration([NotNull] Java9Parser.ClassMemberDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterFieldDeclaration([NotNull] Java9Parser.FieldDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitFieldDeclaration([NotNull] Java9Parser.FieldDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterFieldModifier([NotNull] Java9Parser.FieldModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitFieldModifier([NotNull] Java9Parser.FieldModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterVariableDeclaratorList([NotNull] Java9Parser.VariableDeclaratorListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitVariableDeclaratorList([NotNull] Java9Parser.VariableDeclaratorListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterVariableDeclarator([NotNull] Java9Parser.VariableDeclaratorContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitVariableDeclarator([NotNull] Java9Parser.VariableDeclaratorContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterVariableDeclaratorId([NotNull] Java9Parser.VariableDeclaratorIdContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitVariableDeclaratorId([NotNull] Java9Parser.VariableDeclaratorIdContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterVariableInitializer([NotNull] Java9Parser.VariableInitializerContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitVariableInitializer([NotNull] Java9Parser.VariableInitializerContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannType([NotNull] Java9Parser.UnannTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannType([NotNull] Java9Parser.UnannTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannPrimitiveType([NotNull] Java9Parser.UnannPrimitiveTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannPrimitiveType([NotNull] Java9Parser.UnannPrimitiveTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannReferenceType([NotNull] Java9Parser.UnannReferenceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannReferenceType([NotNull] Java9Parser.UnannReferenceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannClassOrInterfaceType([NotNull] Java9Parser.UnannClassOrInterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannClassOrInterfaceType([NotNull] Java9Parser.UnannClassOrInterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannClassType([NotNull] Java9Parser.UnannClassTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannClassType([NotNull] Java9Parser.UnannClassTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannClassType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannClassType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannClassType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannClassType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannInterfaceType([NotNull] Java9Parser.UnannInterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannInterfaceType([NotNull] Java9Parser.UnannInterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannInterfaceType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannInterfaceType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannInterfaceType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannInterfaceType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannTypeVariable([NotNull] Java9Parser.UnannTypeVariableContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannTypeVariable([NotNull] Java9Parser.UnannTypeVariableContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnannArrayType([NotNull] Java9Parser.UnannArrayTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnannArrayType([NotNull] Java9Parser.UnannArrayTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodDeclaration([NotNull] Java9Parser.MethodDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodDeclaration([NotNull] Java9Parser.MethodDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodModifier([NotNull] Java9Parser.MethodModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodModifier([NotNull] Java9Parser.MethodModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodHeader([NotNull] Java9Parser.MethodHeaderContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodHeader([NotNull] Java9Parser.MethodHeaderContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterResult([NotNull] Java9Parser.ResultContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitResult([NotNull] Java9Parser.ResultContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodDeclarator([NotNull] Java9Parser.MethodDeclaratorContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodDeclarator([NotNull] Java9Parser.MethodDeclaratorContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterFormalParameterList([NotNull] Java9Parser.FormalParameterListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitFormalParameterList([NotNull] Java9Parser.FormalParameterListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterFormalParameters([NotNull] Java9Parser.FormalParametersContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitFormalParameters([NotNull] Java9Parser.FormalParametersContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterFormalParameter([NotNull] Java9Parser.FormalParameterContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitFormalParameter([NotNull] Java9Parser.FormalParameterContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterVariableModifier([NotNull] Java9Parser.VariableModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitVariableModifier([NotNull] Java9Parser.VariableModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterLastFormalParameter([NotNull] Java9Parser.LastFormalParameterContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitLastFormalParameter([NotNull] Java9Parser.LastFormalParameterContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterReceiverParameter([NotNull] Java9Parser.ReceiverParameterContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitReceiverParameter([NotNull] Java9Parser.ReceiverParameterContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterThrows_([NotNull] Java9Parser.Throws_Context context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitThrows_([NotNull] Java9Parser.Throws_Context context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterExceptionTypeList([NotNull] Java9Parser.ExceptionTypeListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitExceptionTypeList([NotNull] Java9Parser.ExceptionTypeListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterExceptionType([NotNull] Java9Parser.ExceptionTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitExceptionType([NotNull] Java9Parser.ExceptionTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodBody([NotNull] Java9Parser.MethodBodyContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodBody([NotNull] Java9Parser.MethodBodyContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInstanceInitializer([NotNull] Java9Parser.InstanceInitializerContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInstanceInitializer([NotNull] Java9Parser.InstanceInitializerContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterStaticInitializer([NotNull] Java9Parser.StaticInitializerContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitStaticInitializer([NotNull] Java9Parser.StaticInitializerContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterConstructorDeclaration([NotNull] Java9Parser.ConstructorDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitConstructorDeclaration([NotNull] Java9Parser.ConstructorDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterConstructorModifier([NotNull] Java9Parser.ConstructorModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitConstructorModifier([NotNull] Java9Parser.ConstructorModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterConstructorDeclarator([NotNull] Java9Parser.ConstructorDeclaratorContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitConstructorDeclarator([NotNull] Java9Parser.ConstructorDeclaratorContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSimpleTypeName([NotNull] Java9Parser.SimpleTypeNameContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSimpleTypeName([NotNull] Java9Parser.SimpleTypeNameContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterConstructorBody([NotNull] Java9Parser.ConstructorBodyContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitConstructorBody([NotNull] Java9Parser.ConstructorBodyContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterExplicitConstructorInvocation([NotNull] Java9Parser.ExplicitConstructorInvocationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitExplicitConstructorInvocation([NotNull] Java9Parser.ExplicitConstructorInvocationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterEnumDeclaration([NotNull] Java9Parser.EnumDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitEnumDeclaration([NotNull] Java9Parser.EnumDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterEnumBody([NotNull] Java9Parser.EnumBodyContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitEnumBody([NotNull] Java9Parser.EnumBodyContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterEnumConstantList([NotNull] Java9Parser.EnumConstantListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitEnumConstantList([NotNull] Java9Parser.EnumConstantListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterEnumConstant([NotNull] Java9Parser.EnumConstantContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitEnumConstant([NotNull] Java9Parser.EnumConstantContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterEnumConstantModifier([NotNull] Java9Parser.EnumConstantModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitEnumConstantModifier([NotNull] Java9Parser.EnumConstantModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterEnumBodyDeclarations([NotNull] Java9Parser.EnumBodyDeclarationsContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitEnumBodyDeclarations([NotNull] Java9Parser.EnumBodyDeclarationsContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInterfaceDeclaration([NotNull] Java9Parser.InterfaceDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInterfaceDeclaration([NotNull] Java9Parser.InterfaceDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterNormalInterfaceDeclaration([NotNull] Java9Parser.NormalInterfaceDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitNormalInterfaceDeclaration([NotNull] Java9Parser.NormalInterfaceDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInterfaceModifier([NotNull] Java9Parser.InterfaceModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInterfaceModifier([NotNull] Java9Parser.InterfaceModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterExtendsInterfaces([NotNull] Java9Parser.ExtendsInterfacesContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitExtendsInterfaces([NotNull] Java9Parser.ExtendsInterfacesContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInterfaceBody([NotNull] Java9Parser.InterfaceBodyContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInterfaceBody([NotNull] Java9Parser.InterfaceBodyContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInterfaceMemberDeclaration([NotNull] Java9Parser.InterfaceMemberDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInterfaceMemberDeclaration([NotNull] Java9Parser.InterfaceMemberDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterConstantDeclaration([NotNull] Java9Parser.ConstantDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitConstantDeclaration([NotNull] Java9Parser.ConstantDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterConstantModifier([NotNull] Java9Parser.ConstantModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitConstantModifier([NotNull] Java9Parser.ConstantModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInterfaceMethodDeclaration([NotNull] Java9Parser.InterfaceMethodDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInterfaceMethodDeclaration([NotNull] Java9Parser.InterfaceMethodDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInterfaceMethodModifier([NotNull] Java9Parser.InterfaceMethodModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInterfaceMethodModifier([NotNull] Java9Parser.InterfaceMethodModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAnnotationTypeDeclaration([NotNull] Java9Parser.AnnotationTypeDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAnnotationTypeDeclaration([NotNull] Java9Parser.AnnotationTypeDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAnnotationTypeBody([NotNull] Java9Parser.AnnotationTypeBodyContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAnnotationTypeBody([NotNull] Java9Parser.AnnotationTypeBodyContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAnnotationTypeMemberDeclaration([NotNull] Java9Parser.AnnotationTypeMemberDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAnnotationTypeMemberDeclaration([NotNull] Java9Parser.AnnotationTypeMemberDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAnnotationTypeElementDeclaration([NotNull] Java9Parser.AnnotationTypeElementDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAnnotationTypeElementDeclaration([NotNull] Java9Parser.AnnotationTypeElementDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAnnotationTypeElementModifier([NotNull] Java9Parser.AnnotationTypeElementModifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAnnotationTypeElementModifier([NotNull] Java9Parser.AnnotationTypeElementModifierContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterDefaultValue([NotNull] Java9Parser.DefaultValueContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitDefaultValue([NotNull] Java9Parser.DefaultValueContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAnnotation([NotNull] Java9Parser.AnnotationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAnnotation([NotNull] Java9Parser.AnnotationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterNormalAnnotation([NotNull] Java9Parser.NormalAnnotationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitNormalAnnotation([NotNull] Java9Parser.NormalAnnotationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterElementValuePairList([NotNull] Java9Parser.ElementValuePairListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitElementValuePairList([NotNull] Java9Parser.ElementValuePairListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterElementValuePair([NotNull] Java9Parser.ElementValuePairContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitElementValuePair([NotNull] Java9Parser.ElementValuePairContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterElementValue([NotNull] Java9Parser.ElementValueContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitElementValue([NotNull] Java9Parser.ElementValueContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterElementValueArrayInitializer([NotNull] Java9Parser.ElementValueArrayInitializerContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitElementValueArrayInitializer([NotNull] Java9Parser.ElementValueArrayInitializerContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterElementValueList([NotNull] Java9Parser.ElementValueListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitElementValueList([NotNull] Java9Parser.ElementValueListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMarkerAnnotation([NotNull] Java9Parser.MarkerAnnotationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMarkerAnnotation([NotNull] Java9Parser.MarkerAnnotationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSingleElementAnnotation([NotNull] Java9Parser.SingleElementAnnotationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSingleElementAnnotation([NotNull] Java9Parser.SingleElementAnnotationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterArrayInitializer([NotNull] Java9Parser.ArrayInitializerContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitArrayInitializer([NotNull] Java9Parser.ArrayInitializerContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterVariableInitializerList([NotNull] Java9Parser.VariableInitializerListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitVariableInitializerList([NotNull] Java9Parser.VariableInitializerListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterBlock([NotNull] Java9Parser.BlockContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitBlock([NotNull] Java9Parser.BlockContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterBlockStatements([NotNull] Java9Parser.BlockStatementsContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitBlockStatements([NotNull] Java9Parser.BlockStatementsContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterBlockStatement([NotNull] Java9Parser.BlockStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitBlockStatement([NotNull] Java9Parser.BlockStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterLocalVariableDeclarationStatement([NotNull] Java9Parser.LocalVariableDeclarationStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitLocalVariableDeclarationStatement([NotNull] Java9Parser.LocalVariableDeclarationStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterLocalVariableDeclaration([NotNull] Java9Parser.LocalVariableDeclarationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitLocalVariableDeclaration([NotNull] Java9Parser.LocalVariableDeclarationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterStatement([NotNull] Java9Parser.StatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitStatement([NotNull] Java9Parser.StatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterStatementNoShortIf([NotNull] Java9Parser.StatementNoShortIfContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitStatementNoShortIf([NotNull] Java9Parser.StatementNoShortIfContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterStatementWithoutTrailingSubstatement([NotNull] Java9Parser.StatementWithoutTrailingSubstatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitStatementWithoutTrailingSubstatement([NotNull] Java9Parser.StatementWithoutTrailingSubstatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterEmptyStatement([NotNull] Java9Parser.EmptyStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitEmptyStatement([NotNull] Java9Parser.EmptyStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterLabeledStatement([NotNull] Java9Parser.LabeledStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitLabeledStatement([NotNull] Java9Parser.LabeledStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterLabeledStatementNoShortIf([NotNull] Java9Parser.LabeledStatementNoShortIfContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitLabeledStatementNoShortIf([NotNull] Java9Parser.LabeledStatementNoShortIfContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterExpressionStatement([NotNull] Java9Parser.ExpressionStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitExpressionStatement([NotNull] Java9Parser.ExpressionStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterStatementExpression([NotNull] Java9Parser.StatementExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitStatementExpression([NotNull] Java9Parser.StatementExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterIfThenStatement([NotNull] Java9Parser.IfThenStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitIfThenStatement([NotNull] Java9Parser.IfThenStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterIfThenElseStatement([NotNull] Java9Parser.IfThenElseStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitIfThenElseStatement([NotNull] Java9Parser.IfThenElseStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterIfThenElseStatementNoShortIf([NotNull] Java9Parser.IfThenElseStatementNoShortIfContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitIfThenElseStatementNoShortIf([NotNull] Java9Parser.IfThenElseStatementNoShortIfContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAssertStatement([NotNull] Java9Parser.AssertStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAssertStatement([NotNull] Java9Parser.AssertStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSwitchStatement([NotNull] Java9Parser.SwitchStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSwitchStatement([NotNull] Java9Parser.SwitchStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSwitchBlock([NotNull] Java9Parser.SwitchBlockContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSwitchBlock([NotNull] Java9Parser.SwitchBlockContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSwitchBlockStatementGroup([NotNull] Java9Parser.SwitchBlockStatementGroupContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSwitchBlockStatementGroup([NotNull] Java9Parser.SwitchBlockStatementGroupContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSwitchLabels([NotNull] Java9Parser.SwitchLabelsContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSwitchLabels([NotNull] Java9Parser.SwitchLabelsContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSwitchLabel([NotNull] Java9Parser.SwitchLabelContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSwitchLabel([NotNull] Java9Parser.SwitchLabelContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterEnumConstantName([NotNull] Java9Parser.EnumConstantNameContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitEnumConstantName([NotNull] Java9Parser.EnumConstantNameContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterWhileStatement([NotNull] Java9Parser.WhileStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitWhileStatement([NotNull] Java9Parser.WhileStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterWhileStatementNoShortIf([NotNull] Java9Parser.WhileStatementNoShortIfContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitWhileStatementNoShortIf([NotNull] Java9Parser.WhileStatementNoShortIfContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterDoStatement([NotNull] Java9Parser.DoStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitDoStatement([NotNull] Java9Parser.DoStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterForStatement([NotNull] Java9Parser.ForStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitForStatement([NotNull] Java9Parser.ForStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterForStatementNoShortIf([NotNull] Java9Parser.ForStatementNoShortIfContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitForStatementNoShortIf([NotNull] Java9Parser.ForStatementNoShortIfContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterBasicForStatement([NotNull] Java9Parser.BasicForStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitBasicForStatement([NotNull] Java9Parser.BasicForStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterBasicForStatementNoShortIf([NotNull] Java9Parser.BasicForStatementNoShortIfContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitBasicForStatementNoShortIf([NotNull] Java9Parser.BasicForStatementNoShortIfContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterForInit([NotNull] Java9Parser.ForInitContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitForInit([NotNull] Java9Parser.ForInitContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterForUpdate([NotNull] Java9Parser.ForUpdateContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitForUpdate([NotNull] Java9Parser.ForUpdateContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterStatementExpressionList([NotNull] Java9Parser.StatementExpressionListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitStatementExpressionList([NotNull] Java9Parser.StatementExpressionListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterEnhancedForStatement([NotNull] Java9Parser.EnhancedForStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitEnhancedForStatement([NotNull] Java9Parser.EnhancedForStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterEnhancedForStatementNoShortIf([NotNull] Java9Parser.EnhancedForStatementNoShortIfContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitEnhancedForStatementNoShortIf([NotNull] Java9Parser.EnhancedForStatementNoShortIfContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterBreakStatement([NotNull] Java9Parser.BreakStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitBreakStatement([NotNull] Java9Parser.BreakStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterContinueStatement([NotNull] Java9Parser.ContinueStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitContinueStatement([NotNull] Java9Parser.ContinueStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterReturnStatement([NotNull] Java9Parser.ReturnStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitReturnStatement([NotNull] Java9Parser.ReturnStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterThrowStatement([NotNull] Java9Parser.ThrowStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitThrowStatement([NotNull] Java9Parser.ThrowStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterSynchronizedStatement([NotNull] Java9Parser.SynchronizedStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitSynchronizedStatement([NotNull] Java9Parser.SynchronizedStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTryStatement([NotNull] Java9Parser.TryStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTryStatement([NotNull] Java9Parser.TryStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterCatches([NotNull] Java9Parser.CatchesContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitCatches([NotNull] Java9Parser.CatchesContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterCatchClause([NotNull] Java9Parser.CatchClauseContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitCatchClause([NotNull] Java9Parser.CatchClauseContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterCatchFormalParameter([NotNull] Java9Parser.CatchFormalParameterContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitCatchFormalParameter([NotNull] Java9Parser.CatchFormalParameterContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterCatchType([NotNull] Java9Parser.CatchTypeContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitCatchType([NotNull] Java9Parser.CatchTypeContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterFinally_([NotNull] Java9Parser.Finally_Context context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitFinally_([NotNull] Java9Parser.Finally_Context context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTryWithResourcesStatement([NotNull] Java9Parser.TryWithResourcesStatementContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTryWithResourcesStatement([NotNull] Java9Parser.TryWithResourcesStatementContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterResourceSpecification([NotNull] Java9Parser.ResourceSpecificationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitResourceSpecification([NotNull] Java9Parser.ResourceSpecificationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterResourceList([NotNull] Java9Parser.ResourceListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitResourceList([NotNull] Java9Parser.ResourceListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterResource([NotNull] Java9Parser.ResourceContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitResource([NotNull] Java9Parser.ResourceContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterVariableAccess([NotNull] Java9Parser.VariableAccessContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitVariableAccess([NotNull] Java9Parser.VariableAccessContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPrimary([NotNull] Java9Parser.PrimaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPrimary([NotNull] Java9Parser.PrimaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPrimaryNoNewArray([NotNull] Java9Parser.PrimaryNoNewArrayContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPrimaryNoNewArray([NotNull] Java9Parser.PrimaryNoNewArrayContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPrimaryNoNewArray_lf_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lf_arrayAccessContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPrimaryNoNewArray_lf_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lf_arrayAccessContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPrimaryNoNewArray_lfno_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lfno_arrayAccessContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPrimaryNoNewArray_lfno_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lfno_arrayAccessContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPrimaryNoNewArray_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPrimaryNoNewArray_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPrimaryNoNewArray_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPrimaryNoNewArray_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassLiteral([NotNull] Java9Parser.ClassLiteralContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassLiteral([NotNull] Java9Parser.ClassLiteralContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassInstanceCreationExpression([NotNull] Java9Parser.ClassInstanceCreationExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassInstanceCreationExpression([NotNull] Java9Parser.ClassInstanceCreationExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassInstanceCreationExpression_lf_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lf_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassInstanceCreationExpression_lf_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lf_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterClassInstanceCreationExpression_lfno_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lfno_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitClassInstanceCreationExpression_lfno_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lfno_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterTypeArgumentsOrDiamond([NotNull] Java9Parser.TypeArgumentsOrDiamondContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitTypeArgumentsOrDiamond([NotNull] Java9Parser.TypeArgumentsOrDiamondContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterFieldAccess([NotNull] Java9Parser.FieldAccessContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitFieldAccess([NotNull] Java9Parser.FieldAccessContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterFieldAccess_lf_primary([NotNull] Java9Parser.FieldAccess_lf_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitFieldAccess_lf_primary([NotNull] Java9Parser.FieldAccess_lf_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterFieldAccess_lfno_primary([NotNull] Java9Parser.FieldAccess_lfno_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitFieldAccess_lfno_primary([NotNull] Java9Parser.FieldAccess_lfno_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterArrayAccess([NotNull] Java9Parser.ArrayAccessContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitArrayAccess([NotNull] Java9Parser.ArrayAccessContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterArrayAccess_lf_primary([NotNull] Java9Parser.ArrayAccess_lf_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitArrayAccess_lf_primary([NotNull] Java9Parser.ArrayAccess_lf_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterArrayAccess_lfno_primary([NotNull] Java9Parser.ArrayAccess_lfno_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitArrayAccess_lfno_primary([NotNull] Java9Parser.ArrayAccess_lfno_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodInvocation([NotNull] Java9Parser.MethodInvocationContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodInvocation([NotNull] Java9Parser.MethodInvocationContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodInvocation_lf_primary([NotNull] Java9Parser.MethodInvocation_lf_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodInvocation_lf_primary([NotNull] Java9Parser.MethodInvocation_lf_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodInvocation_lfno_primary([NotNull] Java9Parser.MethodInvocation_lfno_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodInvocation_lfno_primary([NotNull] Java9Parser.MethodInvocation_lfno_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterArgumentList([NotNull] Java9Parser.ArgumentListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitArgumentList([NotNull] Java9Parser.ArgumentListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodReference([NotNull] Java9Parser.MethodReferenceContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodReference([NotNull] Java9Parser.MethodReferenceContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodReference_lf_primary([NotNull] Java9Parser.MethodReference_lf_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodReference_lf_primary([NotNull] Java9Parser.MethodReference_lf_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMethodReference_lfno_primary([NotNull] Java9Parser.MethodReference_lfno_primaryContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMethodReference_lfno_primary([NotNull] Java9Parser.MethodReference_lfno_primaryContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterArrayCreationExpression([NotNull] Java9Parser.ArrayCreationExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitArrayCreationExpression([NotNull] Java9Parser.ArrayCreationExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterDimExprs([NotNull] Java9Parser.DimExprsContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitDimExprs([NotNull] Java9Parser.DimExprsContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterDimExpr([NotNull] Java9Parser.DimExprContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitDimExpr([NotNull] Java9Parser.DimExprContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterConstantExpression([NotNull] Java9Parser.ConstantExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitConstantExpression([NotNull] Java9Parser.ConstantExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterExpression([NotNull] Java9Parser.ExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitExpression([NotNull] Java9Parser.ExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterLambdaExpression([NotNull] Java9Parser.LambdaExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitLambdaExpression([NotNull] Java9Parser.LambdaExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterLambdaParameters([NotNull] Java9Parser.LambdaParametersContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitLambdaParameters([NotNull] Java9Parser.LambdaParametersContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInferredFormalParameterList([NotNull] Java9Parser.InferredFormalParameterListContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInferredFormalParameterList([NotNull] Java9Parser.InferredFormalParameterListContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterLambdaBody([NotNull] Java9Parser.LambdaBodyContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitLambdaBody([NotNull] Java9Parser.LambdaBodyContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAssignmentExpression([NotNull] Java9Parser.AssignmentExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAssignmentExpression([NotNull] Java9Parser.AssignmentExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAssignment([NotNull] Java9Parser.AssignmentContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAssignment([NotNull] Java9Parser.AssignmentContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterLeftHandSide([NotNull] Java9Parser.LeftHandSideContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitLeftHandSide([NotNull] Java9Parser.LeftHandSideContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAssignmentOperator([NotNull] Java9Parser.AssignmentOperatorContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAssignmentOperator([NotNull] Java9Parser.AssignmentOperatorContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterConditionalExpression([NotNull] Java9Parser.ConditionalExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitConditionalExpression([NotNull] Java9Parser.ConditionalExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterConditionalOrExpression([NotNull] Java9Parser.ConditionalOrExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitConditionalOrExpression([NotNull] Java9Parser.ConditionalOrExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterConditionalAndExpression([NotNull] Java9Parser.ConditionalAndExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitConditionalAndExpression([NotNull] Java9Parser.ConditionalAndExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterInclusiveOrExpression([NotNull] Java9Parser.InclusiveOrExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitInclusiveOrExpression([NotNull] Java9Parser.InclusiveOrExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterExclusiveOrExpression([NotNull] Java9Parser.ExclusiveOrExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitExclusiveOrExpression([NotNull] Java9Parser.ExclusiveOrExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAndExpression([NotNull] Java9Parser.AndExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAndExpression([NotNull] Java9Parser.AndExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterEqualityExpression([NotNull] Java9Parser.EqualityExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitEqualityExpression([NotNull] Java9Parser.EqualityExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterRelationalExpression([NotNull] Java9Parser.RelationalExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitRelationalExpression([NotNull] Java9Parser.RelationalExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterShiftExpression([NotNull] Java9Parser.ShiftExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitShiftExpression([NotNull] Java9Parser.ShiftExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterAdditiveExpression([NotNull] Java9Parser.AdditiveExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitAdditiveExpression([NotNull] Java9Parser.AdditiveExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterMultiplicativeExpression([NotNull] Java9Parser.MultiplicativeExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitMultiplicativeExpression([NotNull] Java9Parser.MultiplicativeExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnaryExpression([NotNull] Java9Parser.UnaryExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnaryExpression([NotNull] Java9Parser.UnaryExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPreIncrementExpression([NotNull] Java9Parser.PreIncrementExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPreIncrementExpression([NotNull] Java9Parser.PreIncrementExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPreDecrementExpression([NotNull] Java9Parser.PreDecrementExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPreDecrementExpression([NotNull] Java9Parser.PreDecrementExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterUnaryExpressionNotPlusMinus([NotNull] Java9Parser.UnaryExpressionNotPlusMinusContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitUnaryExpressionNotPlusMinus([NotNull] Java9Parser.UnaryExpressionNotPlusMinusContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPostfixExpression([NotNull] Java9Parser.PostfixExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPostfixExpression([NotNull] Java9Parser.PostfixExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPostIncrementExpression([NotNull] Java9Parser.PostIncrementExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPostIncrementExpression([NotNull] Java9Parser.PostIncrementExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPostIncrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostIncrementExpression_lf_postfixExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPostIncrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostIncrementExpression_lf_postfixExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPostDecrementExpression([NotNull] Java9Parser.PostDecrementExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPostDecrementExpression([NotNull] Java9Parser.PostDecrementExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterPostDecrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostDecrementExpression_lf_postfixExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitPostDecrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostDecrementExpression_lf_postfixExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterCastExpression([NotNull] Java9Parser.CastExpressionContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitCastExpression([NotNull] Java9Parser.CastExpressionContext context); + /// + /// Enter a parse tree produced by . + /// + /// The parse tree. + void EnterIdentifier([NotNull] Java9Parser.IdentifierContext context); + /// + /// Exit a parse tree produced by . + /// + /// The parse tree. + void ExitIdentifier([NotNull] Java9Parser.IdentifierContext context); +} diff --git a/Tests.Runtime.Standard/Java9/Java9ParserVisitor.cs b/Tests.Runtime.Standard/Java9/Java9ParserVisitor.cs new file mode 100644 index 0000000..05eb472 --- /dev/null +++ b/Tests.Runtime.Standard/Java9/Java9ParserVisitor.cs @@ -0,0 +1,1504 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// ANTLR Version: 4.7.2 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +// Generated from C:\Users\Spitz\source\repos\AntlrBug_40\AntlrConsole3\Java9Parser.g4 by ANTLR 4.7.2 + +// Unreachable code detected +#pragma warning disable 0162 +// The variable '...' is assigned but its value is never used +#pragma warning disable 0219 +// Missing XML comment for publicly visible type or member '...' +#pragma warning disable 1591 +// Ambiguous reference in cref attribute +#pragma warning disable 419 + +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; +using IToken = Antlr4.Runtime.IToken; + +/// +/// This interface defines a complete generic visitor for a parse tree produced +/// by . +/// +/// The return type of the visit operation. +[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.7.2")] +[System.CLSCompliant(false)] +public interface IJava9ParserVisitor : IParseTreeVisitor { + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitLiteral([NotNull] Java9Parser.LiteralContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPrimitiveType([NotNull] Java9Parser.PrimitiveTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitNumericType([NotNull] Java9Parser.NumericTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitIntegralType([NotNull] Java9Parser.IntegralTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitFloatingPointType([NotNull] Java9Parser.FloatingPointTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitReferenceType([NotNull] Java9Parser.ReferenceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassOrInterfaceType([NotNull] Java9Parser.ClassOrInterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassType([NotNull] Java9Parser.ClassTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassType_lf_classOrInterfaceType([NotNull] Java9Parser.ClassType_lf_classOrInterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassType_lfno_classOrInterfaceType([NotNull] Java9Parser.ClassType_lfno_classOrInterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInterfaceType([NotNull] Java9Parser.InterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInterfaceType_lf_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lf_classOrInterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInterfaceType_lfno_classOrInterfaceType([NotNull] Java9Parser.InterfaceType_lfno_classOrInterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeVariable([NotNull] Java9Parser.TypeVariableContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitArrayType([NotNull] Java9Parser.ArrayTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitDims([NotNull] Java9Parser.DimsContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeParameter([NotNull] Java9Parser.TypeParameterContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeParameterModifier([NotNull] Java9Parser.TypeParameterModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeBound([NotNull] Java9Parser.TypeBoundContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAdditionalBound([NotNull] Java9Parser.AdditionalBoundContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeArguments([NotNull] Java9Parser.TypeArgumentsContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeArgumentList([NotNull] Java9Parser.TypeArgumentListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeArgument([NotNull] Java9Parser.TypeArgumentContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitWildcard([NotNull] Java9Parser.WildcardContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitWildcardBounds([NotNull] Java9Parser.WildcardBoundsContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitModuleName([NotNull] Java9Parser.ModuleNameContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPackageName([NotNull] Java9Parser.PackageNameContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeName([NotNull] Java9Parser.TypeNameContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPackageOrTypeName([NotNull] Java9Parser.PackageOrTypeNameContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitExpressionName([NotNull] Java9Parser.ExpressionNameContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodName([NotNull] Java9Parser.MethodNameContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAmbiguousName([NotNull] Java9Parser.AmbiguousNameContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitCompilationUnit([NotNull] Java9Parser.CompilationUnitContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitOrdinaryCompilation([NotNull] Java9Parser.OrdinaryCompilationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitModularCompilation([NotNull] Java9Parser.ModularCompilationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPackageDeclaration([NotNull] Java9Parser.PackageDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPackageModifier([NotNull] Java9Parser.PackageModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitImportDeclaration([NotNull] Java9Parser.ImportDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSingleTypeImportDeclaration([NotNull] Java9Parser.SingleTypeImportDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeImportOnDemandDeclaration([NotNull] Java9Parser.TypeImportOnDemandDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSingleStaticImportDeclaration([NotNull] Java9Parser.SingleStaticImportDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitStaticImportOnDemandDeclaration([NotNull] Java9Parser.StaticImportOnDemandDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeDeclaration([NotNull] Java9Parser.TypeDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitModuleDeclaration([NotNull] Java9Parser.ModuleDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitModuleDirective([NotNull] Java9Parser.ModuleDirectiveContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitRequiresModifier([NotNull] Java9Parser.RequiresModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassDeclaration([NotNull] Java9Parser.ClassDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitNormalClassDeclaration([NotNull] Java9Parser.NormalClassDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassModifier([NotNull] Java9Parser.ClassModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeParameters([NotNull] Java9Parser.TypeParametersContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeParameterList([NotNull] Java9Parser.TypeParameterListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSuperclass([NotNull] Java9Parser.SuperclassContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSuperinterfaces([NotNull] Java9Parser.SuperinterfacesContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInterfaceTypeList([NotNull] Java9Parser.InterfaceTypeListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassBody([NotNull] Java9Parser.ClassBodyContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassBodyDeclaration([NotNull] Java9Parser.ClassBodyDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassMemberDeclaration([NotNull] Java9Parser.ClassMemberDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitFieldDeclaration([NotNull] Java9Parser.FieldDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitFieldModifier([NotNull] Java9Parser.FieldModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitVariableDeclaratorList([NotNull] Java9Parser.VariableDeclaratorListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitVariableDeclarator([NotNull] Java9Parser.VariableDeclaratorContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitVariableDeclaratorId([NotNull] Java9Parser.VariableDeclaratorIdContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitVariableInitializer([NotNull] Java9Parser.VariableInitializerContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannType([NotNull] Java9Parser.UnannTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannPrimitiveType([NotNull] Java9Parser.UnannPrimitiveTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannReferenceType([NotNull] Java9Parser.UnannReferenceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannClassOrInterfaceType([NotNull] Java9Parser.UnannClassOrInterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannClassType([NotNull] Java9Parser.UnannClassTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannClassType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannClassType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannInterfaceType([NotNull] Java9Parser.UnannInterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannInterfaceType_lf_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannInterfaceType_lfno_unannClassOrInterfaceType([NotNull] Java9Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannTypeVariable([NotNull] Java9Parser.UnannTypeVariableContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnannArrayType([NotNull] Java9Parser.UnannArrayTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodDeclaration([NotNull] Java9Parser.MethodDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodModifier([NotNull] Java9Parser.MethodModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodHeader([NotNull] Java9Parser.MethodHeaderContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitResult([NotNull] Java9Parser.ResultContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodDeclarator([NotNull] Java9Parser.MethodDeclaratorContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitFormalParameterList([NotNull] Java9Parser.FormalParameterListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitFormalParameters([NotNull] Java9Parser.FormalParametersContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitFormalParameter([NotNull] Java9Parser.FormalParameterContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitVariableModifier([NotNull] Java9Parser.VariableModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitLastFormalParameter([NotNull] Java9Parser.LastFormalParameterContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitReceiverParameter([NotNull] Java9Parser.ReceiverParameterContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitThrows_([NotNull] Java9Parser.Throws_Context context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitExceptionTypeList([NotNull] Java9Parser.ExceptionTypeListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitExceptionType([NotNull] Java9Parser.ExceptionTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodBody([NotNull] Java9Parser.MethodBodyContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInstanceInitializer([NotNull] Java9Parser.InstanceInitializerContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitStaticInitializer([NotNull] Java9Parser.StaticInitializerContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitConstructorDeclaration([NotNull] Java9Parser.ConstructorDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitConstructorModifier([NotNull] Java9Parser.ConstructorModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitConstructorDeclarator([NotNull] Java9Parser.ConstructorDeclaratorContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSimpleTypeName([NotNull] Java9Parser.SimpleTypeNameContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitConstructorBody([NotNull] Java9Parser.ConstructorBodyContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitExplicitConstructorInvocation([NotNull] Java9Parser.ExplicitConstructorInvocationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitEnumDeclaration([NotNull] Java9Parser.EnumDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitEnumBody([NotNull] Java9Parser.EnumBodyContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitEnumConstantList([NotNull] Java9Parser.EnumConstantListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitEnumConstant([NotNull] Java9Parser.EnumConstantContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitEnumConstantModifier([NotNull] Java9Parser.EnumConstantModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitEnumBodyDeclarations([NotNull] Java9Parser.EnumBodyDeclarationsContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInterfaceDeclaration([NotNull] Java9Parser.InterfaceDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitNormalInterfaceDeclaration([NotNull] Java9Parser.NormalInterfaceDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInterfaceModifier([NotNull] Java9Parser.InterfaceModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitExtendsInterfaces([NotNull] Java9Parser.ExtendsInterfacesContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInterfaceBody([NotNull] Java9Parser.InterfaceBodyContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInterfaceMemberDeclaration([NotNull] Java9Parser.InterfaceMemberDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitConstantDeclaration([NotNull] Java9Parser.ConstantDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitConstantModifier([NotNull] Java9Parser.ConstantModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInterfaceMethodDeclaration([NotNull] Java9Parser.InterfaceMethodDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInterfaceMethodModifier([NotNull] Java9Parser.InterfaceMethodModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAnnotationTypeDeclaration([NotNull] Java9Parser.AnnotationTypeDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAnnotationTypeBody([NotNull] Java9Parser.AnnotationTypeBodyContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAnnotationTypeMemberDeclaration([NotNull] Java9Parser.AnnotationTypeMemberDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAnnotationTypeElementDeclaration([NotNull] Java9Parser.AnnotationTypeElementDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAnnotationTypeElementModifier([NotNull] Java9Parser.AnnotationTypeElementModifierContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitDefaultValue([NotNull] Java9Parser.DefaultValueContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAnnotation([NotNull] Java9Parser.AnnotationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitNormalAnnotation([NotNull] Java9Parser.NormalAnnotationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitElementValuePairList([NotNull] Java9Parser.ElementValuePairListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitElementValuePair([NotNull] Java9Parser.ElementValuePairContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitElementValue([NotNull] Java9Parser.ElementValueContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitElementValueArrayInitializer([NotNull] Java9Parser.ElementValueArrayInitializerContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitElementValueList([NotNull] Java9Parser.ElementValueListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMarkerAnnotation([NotNull] Java9Parser.MarkerAnnotationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSingleElementAnnotation([NotNull] Java9Parser.SingleElementAnnotationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitArrayInitializer([NotNull] Java9Parser.ArrayInitializerContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitVariableInitializerList([NotNull] Java9Parser.VariableInitializerListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitBlock([NotNull] Java9Parser.BlockContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitBlockStatements([NotNull] Java9Parser.BlockStatementsContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitBlockStatement([NotNull] Java9Parser.BlockStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitLocalVariableDeclarationStatement([NotNull] Java9Parser.LocalVariableDeclarationStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitLocalVariableDeclaration([NotNull] Java9Parser.LocalVariableDeclarationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitStatement([NotNull] Java9Parser.StatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitStatementNoShortIf([NotNull] Java9Parser.StatementNoShortIfContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitStatementWithoutTrailingSubstatement([NotNull] Java9Parser.StatementWithoutTrailingSubstatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitEmptyStatement([NotNull] Java9Parser.EmptyStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitLabeledStatement([NotNull] Java9Parser.LabeledStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitLabeledStatementNoShortIf([NotNull] Java9Parser.LabeledStatementNoShortIfContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitExpressionStatement([NotNull] Java9Parser.ExpressionStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitStatementExpression([NotNull] Java9Parser.StatementExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitIfThenStatement([NotNull] Java9Parser.IfThenStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitIfThenElseStatement([NotNull] Java9Parser.IfThenElseStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitIfThenElseStatementNoShortIf([NotNull] Java9Parser.IfThenElseStatementNoShortIfContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAssertStatement([NotNull] Java9Parser.AssertStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSwitchStatement([NotNull] Java9Parser.SwitchStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSwitchBlock([NotNull] Java9Parser.SwitchBlockContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSwitchBlockStatementGroup([NotNull] Java9Parser.SwitchBlockStatementGroupContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSwitchLabels([NotNull] Java9Parser.SwitchLabelsContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSwitchLabel([NotNull] Java9Parser.SwitchLabelContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitEnumConstantName([NotNull] Java9Parser.EnumConstantNameContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitWhileStatement([NotNull] Java9Parser.WhileStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitWhileStatementNoShortIf([NotNull] Java9Parser.WhileStatementNoShortIfContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitDoStatement([NotNull] Java9Parser.DoStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitForStatement([NotNull] Java9Parser.ForStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitForStatementNoShortIf([NotNull] Java9Parser.ForStatementNoShortIfContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitBasicForStatement([NotNull] Java9Parser.BasicForStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitBasicForStatementNoShortIf([NotNull] Java9Parser.BasicForStatementNoShortIfContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitForInit([NotNull] Java9Parser.ForInitContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitForUpdate([NotNull] Java9Parser.ForUpdateContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitStatementExpressionList([NotNull] Java9Parser.StatementExpressionListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitEnhancedForStatement([NotNull] Java9Parser.EnhancedForStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitEnhancedForStatementNoShortIf([NotNull] Java9Parser.EnhancedForStatementNoShortIfContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitBreakStatement([NotNull] Java9Parser.BreakStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitContinueStatement([NotNull] Java9Parser.ContinueStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitReturnStatement([NotNull] Java9Parser.ReturnStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitThrowStatement([NotNull] Java9Parser.ThrowStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitSynchronizedStatement([NotNull] Java9Parser.SynchronizedStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTryStatement([NotNull] Java9Parser.TryStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitCatches([NotNull] Java9Parser.CatchesContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitCatchClause([NotNull] Java9Parser.CatchClauseContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitCatchFormalParameter([NotNull] Java9Parser.CatchFormalParameterContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitCatchType([NotNull] Java9Parser.CatchTypeContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitFinally_([NotNull] Java9Parser.Finally_Context context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTryWithResourcesStatement([NotNull] Java9Parser.TryWithResourcesStatementContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitResourceSpecification([NotNull] Java9Parser.ResourceSpecificationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitResourceList([NotNull] Java9Parser.ResourceListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitResource([NotNull] Java9Parser.ResourceContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitVariableAccess([NotNull] Java9Parser.VariableAccessContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPrimary([NotNull] Java9Parser.PrimaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPrimaryNoNewArray([NotNull] Java9Parser.PrimaryNoNewArrayContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPrimaryNoNewArray_lf_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lf_arrayAccessContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPrimaryNoNewArray_lfno_arrayAccess([NotNull] Java9Parser.PrimaryNoNewArray_lfno_arrayAccessContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPrimaryNoNewArray_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary([NotNull] Java9Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPrimaryNoNewArray_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary([NotNull] Java9Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassLiteral([NotNull] Java9Parser.ClassLiteralContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassInstanceCreationExpression([NotNull] Java9Parser.ClassInstanceCreationExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassInstanceCreationExpression_lf_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lf_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitClassInstanceCreationExpression_lfno_primary([NotNull] Java9Parser.ClassInstanceCreationExpression_lfno_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitTypeArgumentsOrDiamond([NotNull] Java9Parser.TypeArgumentsOrDiamondContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitFieldAccess([NotNull] Java9Parser.FieldAccessContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitFieldAccess_lf_primary([NotNull] Java9Parser.FieldAccess_lf_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitFieldAccess_lfno_primary([NotNull] Java9Parser.FieldAccess_lfno_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitArrayAccess([NotNull] Java9Parser.ArrayAccessContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitArrayAccess_lf_primary([NotNull] Java9Parser.ArrayAccess_lf_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitArrayAccess_lfno_primary([NotNull] Java9Parser.ArrayAccess_lfno_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodInvocation([NotNull] Java9Parser.MethodInvocationContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodInvocation_lf_primary([NotNull] Java9Parser.MethodInvocation_lf_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodInvocation_lfno_primary([NotNull] Java9Parser.MethodInvocation_lfno_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitArgumentList([NotNull] Java9Parser.ArgumentListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodReference([NotNull] Java9Parser.MethodReferenceContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodReference_lf_primary([NotNull] Java9Parser.MethodReference_lf_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodReference_lfno_primary([NotNull] Java9Parser.MethodReference_lfno_primaryContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitArrayCreationExpression([NotNull] Java9Parser.ArrayCreationExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitDimExprs([NotNull] Java9Parser.DimExprsContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitDimExpr([NotNull] Java9Parser.DimExprContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitConstantExpression([NotNull] Java9Parser.ConstantExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitExpression([NotNull] Java9Parser.ExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitLambdaExpression([NotNull] Java9Parser.LambdaExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitLambdaParameters([NotNull] Java9Parser.LambdaParametersContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInferredFormalParameterList([NotNull] Java9Parser.InferredFormalParameterListContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitLambdaBody([NotNull] Java9Parser.LambdaBodyContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAssignmentExpression([NotNull] Java9Parser.AssignmentExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAssignment([NotNull] Java9Parser.AssignmentContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitLeftHandSide([NotNull] Java9Parser.LeftHandSideContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAssignmentOperator([NotNull] Java9Parser.AssignmentOperatorContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitConditionalExpression([NotNull] Java9Parser.ConditionalExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitConditionalOrExpression([NotNull] Java9Parser.ConditionalOrExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitConditionalAndExpression([NotNull] Java9Parser.ConditionalAndExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitInclusiveOrExpression([NotNull] Java9Parser.InclusiveOrExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitExclusiveOrExpression([NotNull] Java9Parser.ExclusiveOrExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAndExpression([NotNull] Java9Parser.AndExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitEqualityExpression([NotNull] Java9Parser.EqualityExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitRelationalExpression([NotNull] Java9Parser.RelationalExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitShiftExpression([NotNull] Java9Parser.ShiftExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAdditiveExpression([NotNull] Java9Parser.AdditiveExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMultiplicativeExpression([NotNull] Java9Parser.MultiplicativeExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnaryExpression([NotNull] Java9Parser.UnaryExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPreIncrementExpression([NotNull] Java9Parser.PreIncrementExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPreDecrementExpression([NotNull] Java9Parser.PreDecrementExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitUnaryExpressionNotPlusMinus([NotNull] Java9Parser.UnaryExpressionNotPlusMinusContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPostfixExpression([NotNull] Java9Parser.PostfixExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPostIncrementExpression([NotNull] Java9Parser.PostIncrementExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPostIncrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostIncrementExpression_lf_postfixExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPostDecrementExpression([NotNull] Java9Parser.PostDecrementExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitPostDecrementExpression_lf_postfixExpression([NotNull] Java9Parser.PostDecrementExpression_lf_postfixExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitCastExpression([NotNull] Java9Parser.CastExpressionContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitIdentifier([NotNull] Java9Parser.IdentifierContext context); +} diff --git a/Tests.Runtime.Standard/Simple.java b/Tests.Runtime.Standard/Simple.java new file mode 100644 index 0000000..1153b4b --- /dev/null +++ b/Tests.Runtime.Standard/Simple.java @@ -0,0 +1,57 @@ +public class Dog +{ + // Instance Variables + String name; + String breed; + int age; + String color; + + // Constructor Declaration of Class + public Dog(String name, String breed, + int age, String color) + { + this.name = name; + this.breed = breed; + this.age = age; + this.color = color; + } + + // method 1 + public String getName() + { + return name; + } + + // method 2 + public String getBreed() + { + return breed; + } + + // method 3 + public int getAge() + { + return age; + } + + // method 4 + public String getColor() + { + return color; + } + + @Override + public String toString() + { + return(""Hi my name is ""+ this.getName()+ + "".\nMy breed,age and color are "" + + this.getBreed()+"","" + this.getAge()+ + "",""+ this.getColor()); + } + + public static void main(String[] args) + { + Dog tuffy = new Dog(""tuffy"",""papillon"", 5, ""white""); + System.out.println(tuffy.toString()); + } +} \ No newline at end of file diff --git a/Tests.Runtime.Standard/TestContainer.cs b/Tests.Runtime.Standard/TestContainer.cs new file mode 100644 index 0000000..45179d6 --- /dev/null +++ b/Tests.Runtime.Standard/TestContainer.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Xunit; + +namespace ParseTreeVisualizer.Tests { + public partial class TestContainer { + static TestContainer() { + inputs = new[] { "Simple.java", "FormatterTest.java" }.Select(x => File.ReadAllText(x)).ToArray(); + lexerType = typeof(Java9Lexer); + parserType = typeof(Java9Parser); + parseMethod = "compilationUnit"; + } + } +} diff --git a/Tests.Runtime.Standard/Tests.Runtime.Standard.csproj b/Tests.Runtime.Standard/Tests.Runtime.Standard.csproj new file mode 100644 index 0000000..6e0d12f --- /dev/null +++ b/Tests.Runtime.Standard/Tests.Runtime.Standard.csproj @@ -0,0 +1,32 @@ + + + + net472;netcoreapp3.0 + 8.0 + enable + ParseTreeVisualizer.Tests + true + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + Always + + + Always + + + + + + diff --git a/Tests.Runtime/TestContainer.cs b/Tests.Runtime/TestContainer.cs new file mode 100644 index 0000000..6824edd --- /dev/null +++ b/Tests.Runtime/TestContainer.cs @@ -0,0 +1,26 @@ +using Rubberduck.Parsing.Grammar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Xunit; + +namespace ParseTreeVisualizer.Tests { + public partial class TestContainer { + static TestContainer() { + inputs = new[] { + @"Public Sub DoSomething() + Debug.Print ""hi from path 1"" + If True Then + MsgBox ""hello from path 2"" + End If + Debug.Print ""still in path 1"" +End Sub" + }; + lexerType = typeof(VBALexer); + parserType = typeof(VBAParser); + parseMethod = "subStmt"; + } + } +} diff --git a/Tests.Runtime/Tests.Runtime.csproj b/Tests.Runtime/Tests.Runtime.csproj new file mode 100644 index 0000000..eef3614 --- /dev/null +++ b/Tests.Runtime/Tests.Runtime.csproj @@ -0,0 +1,29 @@ + + + + net472 + 8.0 + enable + ParseTreeVisualizer.Tests + true + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + ..\..\rubberduck-vba\Rubberduck\Rubberduck.Parsing\bin\Debug\net46\Rubberduck.Parsing.dll + + + + + + diff --git a/Tests.Shared/CachedValuesFixture.cs b/Tests.Shared/CachedValuesFixture.cs new file mode 100644 index 0000000..3ace95a --- /dev/null +++ b/Tests.Shared/CachedValuesFixture.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ParseTreeVisualizer.Tests { + public class CachedValuesFixture { + public ValueTuple targetsConfigs; + } +} diff --git a/Tests.Shared/Extensions.cs b/Tests.Shared/Extensions.cs new file mode 100644 index 0000000..a3e7b36 --- /dev/null +++ b/Tests.Shared/Extensions.cs @@ -0,0 +1,42 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Xunit; + +namespace ParseTreeVisualizer.Tests { + public static class Extensions { + public static TheoryData ToTheoryData(this IEnumerable src) { + var ret = new TheoryData(); + foreach (var a in src) { + ret.Add(a); + } + return ret; + } + + public static TheoryData ToTheoryData(this IEnumerable<(T1,T2)> src) { + var ret = new TheoryData(); + foreach (var (a, b) in src) { + ret.Add(a, b); + } + return ret; + } + + public static TheoryData ToTheoryData(this IEnumerable<(T1, T2, T3)> src) { + var ret = new TheoryData(); + foreach (var (a, b, c) in src) { + ret.Add(a, b, c); + } + return ret; + } + + public static TheoryData ToTheoryData(this IEnumerable<(T1, T2, T3, T4)> src) { + var ret = new TheoryData(); + foreach (var (a, b, c,d) in src) { + ret.Add(a, b, c,d); + } + return ret; + } + } +} diff --git a/Tests.Shared/GlobalSuppressions.cs b/Tests.Shared/GlobalSuppressions.cs new file mode 100644 index 0000000..81a99eb --- /dev/null +++ b/Tests.Shared/GlobalSuppressions.cs @@ -0,0 +1 @@ +[assembly: System.CLSCompliant(false)] \ No newline at end of file diff --git a/Tests.Shared/NullableAttributes.cs b/Tests.Shared/NullableAttributes.cs new file mode 100644 index 0000000..7b4874f --- /dev/null +++ b/Tests.Shared/NullableAttributes.cs @@ -0,0 +1,81 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// This was copied from https://github.com/dotnet/coreclr/blob/60f1e6265bd1039f023a82e0643b524d6aaf7845/src/System.Private.CoreLib/shared/System/Diagnostics/CodeAnalysis/NullableAttributes.cs +// and updated to have the scope of the attributes be internal. + +namespace System.Diagnostics.CodeAnalysis { + /// Specifies that null is allowed as an input even if the corresponding type disallows it. + [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)] + internal sealed class AllowNullAttribute : Attribute { } + + /// Specifies that null is disallowed as an input even if the corresponding type allows it. + [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)] + internal sealed class DisallowNullAttribute : Attribute { } + + /// Specifies that an output may be null even if the corresponding type disallows it. + [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)] + internal sealed class MaybeNullAttribute : Attribute { } + + /// Specifies that an output will not be null even if the corresponding type allows it. + [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)] + internal sealed class NotNullAttribute : Attribute { } + + /// Specifies that when a method returns , the parameter may be null even if the corresponding type disallows it. + [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] + internal sealed class MaybeNullWhenAttribute : Attribute { + /// Initializes the attribute with the specified return value condition. + /// + /// The return value condition. If the method returns this value, the associated parameter may be null. + /// + public MaybeNullWhenAttribute(bool returnValue) => ReturnValue = returnValue; + + /// Gets the return value condition. + public bool ReturnValue { get; } + } + + /// Specifies that when a method returns , the parameter will not be null even if the corresponding type allows it. + [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] + internal sealed class NotNullWhenAttribute : Attribute { + /// Initializes the attribute with the specified return value condition. + /// + /// The return value condition. If the method returns this value, the associated parameter will not be null. + /// + public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue; + + /// Gets the return value condition. + public bool ReturnValue { get; } + } + + /// Specifies that the output will be non-null if the named parameter is non-null. + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)] + internal sealed class NotNullIfNotNullAttribute : Attribute { + /// Initializes the attribute with the associated parameter name. + /// + /// The associated parameter name. The output will be non-null if the argument to the parameter specified is non-null. + /// + public NotNullIfNotNullAttribute(string parameterName) => ParameterName = parameterName; + + /// Gets the associated parameter name. + public string ParameterName { get; } + } + + /// Applied to a method that will never return under any circumstance. + [AttributeUsage(AttributeTargets.Method, Inherited = false)] + internal sealed class DoesNotReturnAttribute : Attribute { } + + /// Specifies that the method will not return if the associated Boolean parameter is passed the specified value. + [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] + internal sealed class DoesNotReturnIfAttribute : Attribute { + /// Initializes the attribute with the specified parameter value. + /// + /// The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to + /// the associated parameter matches this value. + /// + public DoesNotReturnIfAttribute(bool parameterValue) => ParameterValue = parameterValue; + + /// Gets the condition parameter value. + public bool ParameterValue { get; } + } +} diff --git a/Tests.Shared/TestContainer.cs b/Tests.Shared/TestContainer.cs new file mode 100644 index 0000000..49966ea --- /dev/null +++ b/Tests.Shared/TestContainer.cs @@ -0,0 +1,57 @@ +using Antlr4.Runtime; +using Antlr4.Runtime.Tree; +using ParseTreeVisualizer.Util; +using System; +using System.Linq; +using Xunit; + +namespace ParseTreeVisualizer.Tests { + public partial class TestContainer { + static readonly string[] inputs; + static readonly Type lexerType; + static readonly Type parserType; + static readonly string parseMethod; + + private static Lazy<(object, Config)[]> targetsConfigs = new Lazy<(object, Config)[]>(() => { + return inputs + .SelectMany(input => { + var stream = new AntlrInputStream(input); + var lexer = lexerType!.CreateInstance(new[] { stream }); + var tokens = new CommonTokenStream(lexer); + + var parser = parserType!.CreateInstance(new[] { tokens }); + var tree = (IParseTree)parserType.GetMethod(parseMethod!).Invoke(parser, new object[] { }); + return new object[] { input, tokens, tree }; + }) + .SelectMany(target => { + // This creates new instances of Config each time the lambda expression is called + // The behavior is intended + Config[] configs = Enumerable.Range(0, 4).Select(x => new Config()).ToArray(); + configs.Skip(1).ForEach(x => x.SelectedLexerName = lexerType.Name); + configs.Skip(2).ForEach(x => x.SelectedParserName = parserType.Name); + configs.Skip(3).ForEach(x => x.ParseTokensWithRule = parseMethod); + + return configs.Select(config => (target, config)); + }) + .ToArray(); + }); + + public static TheoryData GetTargetsConfigs => targetsConfigs.Value.ToTheoryData(); + + [Theory] + [MemberData(nameof(GetTargetsConfigs))] + public void ConstructVisualizerData_(object target, Config config) { + var vd = new VisualizerData(target, config); + } + + private static Lazy visualizerDatas = new Lazy(() => targetsConfigs.Value.SelectT((target, config) => new VisualizerData(target, config)).ToArray()); + + public static TheoryData GetVisualizerDatas => visualizerDatas.Value.ToTheoryData(); + + [Theory] + [MemberData(nameof(GetVisualizerDatas))] + public void ConstructVisualizerDataViewModel(VisualizerData vd) { + var vm = new VisualizerDataViewModel(vd); + } + } +} diff --git a/Tests.Shared/Tests.Shared.projitems b/Tests.Shared/Tests.Shared.projitems new file mode 100644 index 0000000..13d5385 --- /dev/null +++ b/Tests.Shared/Tests.Shared.projitems @@ -0,0 +1,18 @@ + + + + $(MSBuildAllProjects);$(MSBuildThisFileFullPath) + true + 20337a6c-c920-43c8-8b34-665d91eadf89 + + + ParseTreeVisualizer.Tests + + + + + + + + + \ No newline at end of file diff --git a/Tests.Shared/Tests.Shared.shproj b/Tests.Shared/Tests.Shared.shproj new file mode 100644 index 0000000..ff630d8 --- /dev/null +++ b/Tests.Shared/Tests.Shared.shproj @@ -0,0 +1,13 @@ + + + + 20337a6c-c920-43c8-8b34-665d91eadf89 + 14.0 + + + + + + + +