diff --git a/ANTLR4ParseTreeVisualizer.Dev.sln b/ANTLR4ParseTreeVisualizer.Dev.sln index 9d715d5..e9b5d89 100644 --- a/ANTLR4ParseTreeVisualizer.Dev.sln +++ b/ANTLR4ParseTreeVisualizer.Dev.sln @@ -39,18 +39,29 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Standard.Package", "Standar EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "_visualizerTestNoRef", "_visualizerTestNoRef\_visualizerTestNoRef.csproj", "{CADA5CBA-1FE0-48A2-BF4F-7158C1CFF44F}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "_visualizerTestStandard", "_visualizerTestStandard\_visualizerTestStandard.csproj", "{1363D6B6-6D48-4A62-A533-3432F74A04F9}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "_visualizerTestStandard", "_visualizerTestStandard\_visualizerTestStandard.csproj", "{1363D6B6-6D48-4A62-A533-3432F74A04F9}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "_visualizerTestStandardNoRef", "_visualizerTestStandardNoRef\_visualizerTestStandardNoRef.csproj", "{05FA4741-B091-4075-8355-53C2BC48AACD}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "_visualizerTestStandardNoRef", "_visualizerTestStandardNoRef\_visualizerTestStandardNoRef.csproj", "{05FA4741-B091-4075-8355-53C2BC48AACD}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Test", "Test", "{74A0EB35-5FC5-40D6-BD6A-199A070ED68D}" +EndProject +Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Test.Shared", "Test\Test.Shared\Test.Shared.shproj", "{ED8BAF15-5B0B-4027-9B23-DD14B24739DB}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Test.Legacy", "Test\Test.Legacy\Test.Legacy.csproj", "{01945C0C-2E1A-4FB7-A26B-544FACEA3DA5}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Test.Standard", "Test\Test.Standard\Test.Standard.csproj", "{0268B6F3-FD77-452C-AFB4-75FA81BF5947}" EndProject Global GlobalSection(SharedMSBuildProjectFiles) = preSolution + Test\Test.Shared\Test.Shared.projitems*{01945c0c-2e1a-4fb7-a26b-544facea3da5}*SharedItemsImports = 5 + Test\Test.Shared\Test.Shared.projitems*{0268b6f3-fd77-452c-afb4-75fa81bf5947}*SharedItemsImports = 5 Debuggee\Debuggee.projitems*{127b215f-f3f8-44df-a2d1-9aaf95b3f8f3}*SharedItemsImports = 13 Visualizer\Visualizer.projitems*{3c553ffd-fa4e-4eab-ad03-9534c7cb8f3e}*SharedItemsImports = 13 Debuggee\Debuggee.projitems*{ae5a655c-c17c-4fbb-be45-13e49a5c7bc8}*SharedItemsImports = 5 Serialization\Serialization.projitems*{ae5a655c-c17c-4fbb-be45-13e49a5c7bc8}*SharedItemsImports = 5 UI\UI.projitems*{e2b06997-76f1-48de-abe6-cf90427423bb}*SharedItemsImports = 13 Serialization\Serialization.projitems*{e3b0367b-3649-4b77-878a-85a8a11c4c09}*SharedItemsImports = 13 + Test\Test.Shared\Test.Shared.projitems*{ed8baf15-5b0b-4027-9b23-dd14b24739db}*SharedItemsImports = 13 EndGlobalSection GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -101,6 +112,14 @@ Global {05FA4741-B091-4075-8355-53C2BC48AACD}.Debug|Any CPU.Build.0 = Debug|Any CPU {05FA4741-B091-4075-8355-53C2BC48AACD}.Release|Any CPU.ActiveCfg = Release|Any CPU {05FA4741-B091-4075-8355-53C2BC48AACD}.Release|Any CPU.Build.0 = Release|Any CPU + {01945C0C-2E1A-4FB7-A26B-544FACEA3DA5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {01945C0C-2E1A-4FB7-A26B-544FACEA3DA5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {01945C0C-2E1A-4FB7-A26B-544FACEA3DA5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {01945C0C-2E1A-4FB7-A26B-544FACEA3DA5}.Release|Any CPU.Build.0 = Release|Any CPU + {0268B6F3-FD77-452C-AFB4-75FA81BF5947}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0268B6F3-FD77-452C-AFB4-75FA81BF5947}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0268B6F3-FD77-452C-AFB4-75FA81BF5947}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0268B6F3-FD77-452C-AFB4-75FA81BF5947}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -112,6 +131,9 @@ Global {74F8A769-77D2-4889-BB81-2FF397C220B9} = {C0ADF39C-DD3F-4EBD-AC9C-7D1E5D5CD0A8} {F09CFEBD-151C-487C-BC87-1EA68B5A4043} = {5F2046EA-A159-4673-B7B9-F1F3179C5D6C} {D7950FB3-F80E-4249-99D1-F08E3A64CA0E} = {C0ADF39C-DD3F-4EBD-AC9C-7D1E5D5CD0A8} + {ED8BAF15-5B0B-4027-9B23-DD14B24739DB} = {74A0EB35-5FC5-40D6-BD6A-199A070ED68D} + {01945C0C-2E1A-4FB7-A26B-544FACEA3DA5} = {74A0EB35-5FC5-40D6-BD6A-199A070ED68D} + {0268B6F3-FD77-452C-AFB4-75FA81BF5947} = {74A0EB35-5FC5-40D6-BD6A-199A070ED68D} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {A2A19EFC-E356-4E97-8752-D94ABBE584B0} diff --git a/ANTLR4ParseTreeVisualizer.sln b/ANTLR4ParseTreeVisualizer.sln index 6f82dee..9f8e9cb 100644 --- a/ANTLR4ParseTreeVisualizer.sln +++ b/ANTLR4ParseTreeVisualizer.sln @@ -33,14 +33,25 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Legacy.Package", "Legacy\Pa EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Standard.Package", "Standard\Package\Standard.Package.csproj", "{D7950FB3-F80E-4249-99D1-F08E3A64CA0E}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Test", "Test", "{740AF50E-F735-4E54-8091-7DF29ABBD05A}" +EndProject +Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Test.Shared", "Test\Test.Shared\Test.Shared.shproj", "{ED8BAF15-5B0B-4027-9B23-DD14B24739DB}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Test.Legacy", "Test\Test.Legacy\Test.Legacy.csproj", "{22587B08-85CE-4383-B754-86808D0713E4}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Test.Standard", "Test\Test.Standard\Test.Standard.csproj", "{40F8B1E1-E78C-4231-8ACE-3EE5A9486609}" +EndProject Global GlobalSection(SharedMSBuildProjectFiles) = preSolution Debuggee\Debuggee.projitems*{127b215f-f3f8-44df-a2d1-9aaf95b3f8f3}*SharedItemsImports = 13 + Test\Test.Shared\Test.Shared.projitems*{22587b08-85ce-4383-b754-86808d0713e4}*SharedItemsImports = 5 Visualizer\Visualizer.projitems*{3c553ffd-fa4e-4eab-ad03-9534c7cb8f3e}*SharedItemsImports = 13 + Test\Test.Shared\Test.Shared.projitems*{40f8b1e1-e78c-4231-8ace-3ee5a9486609}*SharedItemsImports = 5 Debuggee\Debuggee.projitems*{ae5a655c-c17c-4fbb-be45-13e49a5c7bc8}*SharedItemsImports = 5 Serialization\Serialization.projitems*{ae5a655c-c17c-4fbb-be45-13e49a5c7bc8}*SharedItemsImports = 5 UI\UI.projitems*{e2b06997-76f1-48de-abe6-cf90427423bb}*SharedItemsImports = 13 Serialization\Serialization.projitems*{e3b0367b-3649-4b77-878a-85a8a11c4c09}*SharedItemsImports = 13 + Test\Test.Shared\Test.Shared.projitems*{ed8baf15-5b0b-4027-9b23-dd14b24739db}*SharedItemsImports = 13 EndGlobalSection GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -71,6 +82,14 @@ Global {D7950FB3-F80E-4249-99D1-F08E3A64CA0E}.Debug|Any CPU.Build.0 = Debug|Any CPU {D7950FB3-F80E-4249-99D1-F08E3A64CA0E}.Release|Any CPU.ActiveCfg = Release|Any CPU {D7950FB3-F80E-4249-99D1-F08E3A64CA0E}.Release|Any CPU.Build.0 = Release|Any CPU + {22587B08-85CE-4383-B754-86808D0713E4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {22587B08-85CE-4383-B754-86808D0713E4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {22587B08-85CE-4383-B754-86808D0713E4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {22587B08-85CE-4383-B754-86808D0713E4}.Release|Any CPU.Build.0 = Release|Any CPU + {40F8B1E1-E78C-4231-8ACE-3EE5A9486609}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {40F8B1E1-E78C-4231-8ACE-3EE5A9486609}.Debug|Any CPU.Build.0 = Debug|Any CPU + {40F8B1E1-E78C-4231-8ACE-3EE5A9486609}.Release|Any CPU.ActiveCfg = Release|Any CPU + {40F8B1E1-E78C-4231-8ACE-3EE5A9486609}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -82,6 +101,9 @@ Global {74F8A769-77D2-4889-BB81-2FF397C220B9} = {C0ADF39C-DD3F-4EBD-AC9C-7D1E5D5CD0A8} {F09CFEBD-151C-487C-BC87-1EA68B5A4043} = {5F2046EA-A159-4673-B7B9-F1F3179C5D6C} {D7950FB3-F80E-4249-99D1-F08E3A64CA0E} = {C0ADF39C-DD3F-4EBD-AC9C-7D1E5D5CD0A8} + {ED8BAF15-5B0B-4027-9B23-DD14B24739DB} = {740AF50E-F735-4E54-8091-7DF29ABBD05A} + {22587B08-85CE-4383-B754-86808D0713E4} = {740AF50E-F735-4E54-8091-7DF29ABBD05A} + {40F8B1E1-E78C-4231-8ACE-3EE5A9486609} = {740AF50E-F735-4E54-8091-7DF29ABBD05A} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {A2A19EFC-E356-4E97-8752-D94ABBE584B0} diff --git a/Directory.Build.props b/Directory.Build.props new file mode 100644 index 0000000..ad53bdf --- /dev/null +++ b/Directory.Build.props @@ -0,0 +1,7 @@ + + + true + enable + 9.0 + + diff --git a/Legacy/Debuggee/Legacy.Debuggee.csproj b/Legacy/Debuggee/Legacy.Debuggee.csproj index 41ff9a8..1e94692 100644 --- a/Legacy/Debuggee/Legacy.Debuggee.csproj +++ b/Legacy/Debuggee/Legacy.Debuggee.csproj @@ -15,7 +15,7 @@ - + ..\..\..\..\..\..\..\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\IDE\PublicAssemblies\Microsoft.VisualStudio.DebuggerVisualizers.dll diff --git a/Legacy/Debugger/Legacy.Debugger.csproj b/Legacy/Debugger/Legacy.Debugger.csproj index b1f643e..941abc6 100644 --- a/Legacy/Debugger/Legacy.Debugger.csproj +++ b/Legacy/Debugger/Legacy.Debugger.csproj @@ -13,8 +13,8 @@ - - + + ..\..\..\..\..\..\..\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\IDE\PublicAssemblies\Microsoft.VisualStudio.DebuggerVisualizers.dll diff --git a/Legacy/Package/Legacy.Package.csproj b/Legacy/Package/Legacy.Package.csproj index 10c180a..80940a2 100644 --- a/Legacy/Package/Legacy.Package.csproj +++ b/Legacy/Package/Legacy.Package.csproj @@ -1,7 +1,7 @@  - net472 + net472 ParseTreeVisualizer ParseTreeVisualizer.UI.Legacy 9.0 @@ -25,8 +25,8 @@ - - + + diff --git a/Serialization/VisualizerData.cs b/Serialization/VisualizerData.cs index c4f01f5..a646bdf 100644 --- a/Serialization/VisualizerData.cs +++ b/Serialization/VisualizerData.cs @@ -23,10 +23,6 @@ public class VisualizerData { public bool CanSelectLexer { get; } public bool CanSelectParser { get; } - private static readonly string[] ignnoreLoadErrors = new[] { - "Microsoft.Xaml.Behaviors" - }; - public VisualizerData(object o, Config config) { if (config is null) { throw new ArgumentNullException(nameof(config)); } @@ -42,12 +38,10 @@ T createInstance(string typename, object[]? args = null) => .Where(x => x != GetType().Assembly) .SelectMany(x => { var ret = Empty(); - if (!x.FullName.StartsWithAny(ignnoreLoadErrors)) { - try { - ret = x.GetTypes(); - } catch { - AssemblyLoadErrors.Add(x.FullName); - } + try { + ret = x.GetTypes(); + } catch { + AssemblyLoadErrors.Add(x.FullName); } return ret; }) diff --git a/Standard/Debuggee/Standard.Debuggee.csproj b/Standard/Debuggee/Standard.Debuggee.csproj index ef13dc2..90637c3 100644 --- a/Standard/Debuggee/Standard.Debuggee.csproj +++ b/Standard/Debuggee/Standard.Debuggee.csproj @@ -12,7 +12,7 @@ - + ..\..\..\..\..\..\..\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\IDE\PublicAssemblies\Microsoft.VisualStudio.DebuggerVisualizers.dll diff --git a/Standard/Debugger/Standard.Debugger.csproj b/Standard/Debugger/Standard.Debugger.csproj index ea19455..8e195a7 100644 --- a/Standard/Debugger/Standard.Debugger.csproj +++ b/Standard/Debugger/Standard.Debugger.csproj @@ -13,8 +13,8 @@ - - + + ..\..\..\..\..\..\..\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\IDE\PublicAssemblies\Microsoft.VisualStudio.DebuggerVisualizers.dll diff --git a/Standard/Package/Standard.Package.csproj b/Standard/Package/Standard.Package.csproj index 55775b5..6f870f9 100644 --- a/Standard/Package/Standard.Package.csproj +++ b/Standard/Package/Standard.Package.csproj @@ -24,8 +24,8 @@ - - + + diff --git a/Test/Test.Legacy/Test.Legacy.csproj b/Test/Test.Legacy/Test.Legacy.csproj new file mode 100644 index 0000000..b4ef715 --- /dev/null +++ b/Test/Test.Legacy/Test.Legacy.csproj @@ -0,0 +1,47 @@ + + + + net5.0-windows + ParseTreeVisualizer.Test + false + true + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + MSBuild:Compile + ParseTreeVisualizer.Test + False + False + + + + MSBuild:Compile + ParseTreeVisualizer.Test + False + False + + + + + + + diff --git a/Test/Test.Shared/Extensions.cs b/Test/Test.Shared/Extensions.cs new file mode 100644 index 0000000..4428dae --- /dev/null +++ b/Test/Test.Shared/Extensions.cs @@ -0,0 +1,25 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Xunit; + +namespace ParseTreeVisualizer.Test { + public static class Extensions { + 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, 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/Test/Test.Shared/GlobalSuppressions.cs similarity index 100% rename from Tests.Shared/GlobalSuppressions.cs rename to Test/Test.Shared/GlobalSuppressions.cs diff --git a/Test/Test.Shared/Grammar/SQLiteLexer.g4 b/Test/Test.Shared/Grammar/SQLiteLexer.g4 new file mode 100644 index 0000000..0dd1918 --- /dev/null +++ b/Test/Test.Shared/Grammar/SQLiteLexer.g4 @@ -0,0 +1,267 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2020 by Martin Mirchev + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and + * associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or + * substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT + * NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Project : sqlite-parser; an ANTLR4 grammar for SQLite https://github.com/bkiers/sqlite-parser + * Developed by : Bart Kiers, bart@big-o.nl + */ + +// $antlr-format alignTrailingComments on, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments off, useTab off +// $antlr-format allowShortRulesOnASingleLine on, alignSemicolons ownLine + +lexer grammar SQLiteLexer; + +SCOL: ';'; +DOT: '.'; +OPEN_PAR: '('; +CLOSE_PAR: ')'; +COMMA: ','; +ASSIGN: '='; +STAR: '*'; +PLUS: '+'; +MINUS: '-'; +TILDE: '~'; +PIPE2: '||'; +DIV: '/'; +MOD: '%'; +LT2: '<<'; +GT2: '>>'; +AMP: '&'; +PIPE: '|'; +LT: '<'; +LT_EQ: '<='; +GT: '>'; +GT_EQ: '>='; +EQ: '=='; +NOT_EQ1: '!='; +NOT_EQ2: '<>'; + +// http://www.sqlite.org/lang_keywords.html +ABORT_: A B O R T; +ACTION_: A C T I O N; +ADD_: A D D; +AFTER_: A F T E R; +ALL_: A L L; +ALTER_: A L T E R; +ANALYZE_: A N A L Y Z E; +AND_: A N D; +AS_: A S; +ASC_: A S C; +ATTACH_: A T T A C H; +AUTOINCREMENT_: A U T O I N C R E M E N T; +BEFORE_: B E F O R E; +BEGIN_: B E G I N; +BETWEEN_: B E T W E E N; +BY_: B Y; +CASCADE_: C A S C A D E; +CASE_: C A S E; +CAST_: C A S T; +CHECK_: C H E C K; +COLLATE_: C O L L A T E; +COLUMN_: C O L U M N; +COMMIT_: C O M M I T; +CONFLICT_: C O N F L I C T; +CONSTRAINT_: C O N S T R A I N T; +CREATE_: C R E A T E; +CROSS_: C R O S S; +CURRENT_DATE_: C U R R E N T '_' D A T E; +CURRENT_TIME_: C U R R E N T '_' T I M E; +CURRENT_TIMESTAMP_: C U R R E N T '_' T I M E S T A M P; +DATABASE_: D A T A B A S E; +DEFAULT_: D E F A U L T; +DEFERRABLE_: D E F E R R A B L E; +DEFERRED_: D E F E R R E D; +DELETE_: D E L E T E; +DESC_: D E S C; +DETACH_: D E T A C H; +DISTINCT_: D I S T I N C T; +DROP_: D R O P; +EACH_: E A C H; +ELSE_: E L S E; +END_: E N D; +ESCAPE_: E S C A P E; +EXCEPT_: E X C E P T; +EXCLUSIVE_: E X C L U S I V E; +EXISTS_: E X I S T S; +EXPLAIN_: E X P L A I N; +FAIL_: F A I L; +FOR_: F O R; +FOREIGN_: F O R E I G N; +FROM_: F R O M; +FULL_: F U L L; +GLOB_: G L O B; +GROUP_: G R O U P; +HAVING_: H A V I N G; +IF_: I F; +IGNORE_: I G N O R E; +IMMEDIATE_: I M M E D I A T E; +IN_: I N; +INDEX_: I N D E X; +INDEXED_: I N D E X E D; +INITIALLY_: I N I T I A L L Y; +INNER_: I N N E R; +INSERT_: I N S E R T; +INSTEAD_: I N S T E A D; +INTERSECT_: I N T E R S E C T; +INTO_: I N T O; +IS_: I S; +ISNULL_: I S N U L L; +JOIN_: J O I N; +KEY_: K E Y; +LEFT_: L E F T; +LIKE_: L I K E; +LIMIT_: L I M I T; +MATCH_: M A T C H; +NATURAL_: N A T U R A L; +NO_: N O; +NOT_: N O T; +NOTNULL_: N O T N U L L; +NULL_: N U L L; +OF_: O F; +OFFSET_: O F F S E T; +ON_: O N; +OR_: O R; +ORDER_: O R D E R; +OUTER_: O U T E R; +PLAN_: P L A N; +PRAGMA_: P R A G M A; +PRIMARY_: P R I M A R Y; +QUERY_: Q U E R Y; +RAISE_: R A I S E; +RECURSIVE_: R E C U R S I V E; +REFERENCES_: R E F E R E N C E S; +REGEXP_: R E G E X P; +REINDEX_: R E I N D E X; +RELEASE_: R E L E A S E; +RENAME_: R E N A M E; +REPLACE_: R E P L A C E; +RESTRICT_: R E S T R I C T; +RIGHT_: R I G H T; +ROLLBACK_: R O L L B A C K; +ROW_: R O W; +ROWS_: R O W S; +SAVEPOINT_: S A V E P O I N T; +SELECT_: S E L E C T; +SET_: S E T; +TABLE_: T A B L E; +TEMP_: T E M P; +TEMPORARY_: T E M P O R A R Y; +THEN_: T H E N; +TO_: T O; +TRANSACTION_: T R A N S A C T I O N; +TRIGGER_: T R I G G E R; +UNION_: U N I O N; +UNIQUE_: U N I Q U E; +UPDATE_: U P D A T E; +USING_: U S I N G; +VACUUM_: V A C U U M; +VALUES_: V A L U E S; +VIEW_: V I E W; +VIRTUAL_: V I R T U A L; +WHEN_: W H E N; +WHERE_: W H E R E; +WITH_: W I T H; +WITHOUT_: W I T H O U T; +FIRST_VALUE_: F I R S T '_' V A L U E; +OVER_: O V E R; +PARTITION_: P A R T I T I O N; +RANGE_: R A N G E; +PRECEDING_: P R E C E D I N G; +UNBOUNDED_: U N B O U N D E D; +CURRENT_: C U R R E N T; +FOLLOWING_: F O L L O W I N G; +CUME_DIST_: C U M E '_' D I S T; +DENSE_RANK_: D E N S E '_' R A N K; +LAG_: L A G; +LAST_VALUE_: L A S T '_' V A L U E; +LEAD_: L E A D; +NTH_VALUE_: N T H '_' V A L U E; +NTILE_: N T I L E; +PERCENT_RANK_: P E R C E N T '_' R A N K; +RANK_: R A N K; +ROW_NUMBER_: R O W '_' N U M B E R; +GENERATED_: G E N E R A T E D; +ALWAYS_: A L W A Y S; +STORED_: S T O R E D; +TRUE_: T R U E; +FALSE_: F A L S E; +WINDOW_: W I N D O W; +NULLS_: N U L L S; +FIRST_: F I R S T; +LAST_: L A S T; +FILTER_: F I L T E R; +GROUPS_: G R O U P S; +EXCLUDE_: E X C L U D E; +TIES_: T I E S; +OTHERS_: O T H E R S; +DO_: D O; +NOTHING_: N O T H I N G; + +IDENTIFIER: + '"' (~'"' | '""')* '"' + | '`' (~'`' | '``')* '`' + | '[' ~']'* ']' + | [a-zA-Z_] [a-zA-Z_0-9]* +; // TODO check: needs more chars in set + +NUMERIC_LITERAL: ((DIGIT+ ('.' DIGIT*)?) | ('.' DIGIT+)) (E [-+]? DIGIT+)? | '0x' HEX_DIGIT+; + +BIND_PARAMETER: '?' DIGIT* | [:@$] IDENTIFIER; + +STRING_LITERAL: '\'' ( ~'\'' | '\'\'')* '\''; + +BLOB_LITERAL: X STRING_LITERAL; + +SINGLE_LINE_COMMENT: '--' ~[\r\n]* (('\r'? '\n') | EOF) -> channel(HIDDEN); + +MULTILINE_COMMENT: '/*' .*? '*/' -> channel(HIDDEN); + +SPACES: [ \u000B\t\r\n] -> channel(HIDDEN); + +UNEXPECTED_CHAR: .; + +fragment HEX_DIGIT: [0-9a-fA-F]; +fragment DIGIT: [0-9]; + +fragment A: [aA]; +fragment B: [bB]; +fragment C: [cC]; +fragment D: [dD]; +fragment E: [eE]; +fragment F: [fF]; +fragment G: [gG]; +fragment H: [hH]; +fragment I: [iI]; +fragment J: [jJ]; +fragment K: [kK]; +fragment L: [lL]; +fragment M: [mM]; +fragment N: [nN]; +fragment O: [oO]; +fragment P: [pP]; +fragment Q: [qQ]; +fragment R: [rR]; +fragment S: [sS]; +fragment T: [tT]; +fragment U: [uU]; +fragment V: [vV]; +fragment W: [wW]; +fragment X: [xX]; +fragment Y: [yY]; +fragment Z: [zZ]; diff --git a/Test/Test.Shared/Grammar/SQLiteParser.g4 b/Test/Test.Shared/Grammar/SQLiteParser.g4 new file mode 100644 index 0000000..ff411c6 --- /dev/null +++ b/Test/Test.Shared/Grammar/SQLiteParser.g4 @@ -0,0 +1,904 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2014 by Bart Kiers + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and + * associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or + * substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT + * NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Project : sqlite-parser; an ANTLR4 grammar for SQLite https://github.com/bkiers/sqlite-parser + * Developed by: + * Bart Kiers, bart@big-o.nl + * Martin Mirchev, marti_2203@abv.bg + * Mike Lische, mike@lischke-online.de + */ + +// $antlr-format alignTrailingComments on, columnLimit 130, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments off +// $antlr-format useTab off, allowShortRulesOnASingleLine off, allowShortBlocksOnASingleLine on, alignSemicolons ownLine + +parser grammar SQLiteParser; + +options { + tokenVocab = SQLiteLexer; +} + +parse: (sql_stmt_list)* EOF +; + +sql_stmt_list: + SCOL* sql_stmt (SCOL+ sql_stmt)* SCOL* +; + +sql_stmt: (EXPLAIN_ (QUERY_ PLAN_)?)? ( + alter_table_stmt + | analyze_stmt + | attach_stmt + | begin_stmt + | commit_stmt + | create_index_stmt + | create_table_stmt + | create_trigger_stmt + | create_view_stmt + | create_virtual_table_stmt + | delete_stmt + | delete_stmt_limited + | detach_stmt + | drop_stmt + | insert_stmt + | pragma_stmt + | reindex_stmt + | release_stmt + | rollback_stmt + | savepoint_stmt + | select_stmt + | update_stmt + | update_stmt_limited + | vacuum_stmt + ) +; + +alter_table_stmt: + ALTER_ TABLE_ (schema_name DOT)? table_name ( + RENAME_ ( + TO_ new_table_name + | COLUMN_? old_column_name = column_name TO_ new_column_name = column_name + ) + | ADD_ COLUMN_? column_def + ) +; + +analyze_stmt: + ANALYZE_ (schema_name | (schema_name DOT)? table_or_index_name)? +; + +attach_stmt: + ATTACH_ DATABASE_? expr AS_ schema_name +; + +begin_stmt: + BEGIN_ (DEFERRED_ | IMMEDIATE_ | EXCLUSIVE_)? ( + TRANSACTION_ transaction_name? + )? +; + +commit_stmt: (COMMIT_ | END_) TRANSACTION_? +; + +rollback_stmt: + ROLLBACK_ TRANSACTION_? (TO_ SAVEPOINT_? savepoint_name)? +; + +savepoint_stmt: + SAVEPOINT_ savepoint_name +; + +release_stmt: + RELEASE_ SAVEPOINT_? savepoint_name +; + +create_index_stmt: + CREATE_ UNIQUE_? INDEX_ (IF_ NOT_ EXISTS_)? (schema_name DOT)? index_name ON_ table_name OPEN_PAR + indexed_column (COMMA indexed_column)* CLOSE_PAR (WHERE_ expr)? +; + +indexed_column: (column_name | expr) (COLLATE_ collation_name)? asc_desc? +; + +create_table_stmt: + CREATE_ (TEMP_ | TEMPORARY_)? TABLE_ (IF_ NOT_ EXISTS_)? ( + schema_name DOT + )? table_name ( + OPEN_PAR column_def (COMMA column_def)*? (COMMA table_constraint)* CLOSE_PAR ( + WITHOUT_ row_ROW_ID = IDENTIFIER + )? + | AS_ select_stmt + ) +; + +column_def: + column_name type_name? column_constraint* +; + +type_name: + name+? ( + OPEN_PAR signed_number CLOSE_PAR + | OPEN_PAR signed_number COMMA signed_number CLOSE_PAR + )? +; + +column_constraint: (CONSTRAINT_ name)? ( + (PRIMARY_ KEY_ asc_desc? conflict_clause? AUTOINCREMENT_?) + | (NOT_ NULL_ | UNIQUE_) conflict_clause? + | CHECK_ OPEN_PAR expr CLOSE_PAR + | DEFAULT_ (signed_number | literal_value | OPEN_PAR expr CLOSE_PAR) + | COLLATE_ collation_name + | foreign_key_clause + | (GENERATED_ ALWAYS_)? AS_ OPEN_PAR expr CLOSE_PAR ( + STORED_ + | VIRTUAL_ + )? + ) +; + +signed_number: (PLUS | MINUS)? NUMERIC_LITERAL +; + +table_constraint: (CONSTRAINT_ name)? ( + (PRIMARY_ KEY_ | UNIQUE_) OPEN_PAR indexed_column ( + COMMA indexed_column + )* CLOSE_PAR conflict_clause? + | CHECK_ OPEN_PAR expr CLOSE_PAR + | FOREIGN_ KEY_ OPEN_PAR column_name (COMMA column_name)* CLOSE_PAR foreign_key_clause + ) +; + +foreign_key_clause: + REFERENCES_ foreign_table ( + OPEN_PAR column_name (COMMA column_name)* CLOSE_PAR + )? ( + ON_ (DELETE_ | UPDATE_) ( + SET_ (NULL_ | DEFAULT_) + | CASCADE_ + | RESTRICT_ + | NO_ ACTION_ + ) + | MATCH_ name + )* (NOT_? DEFERRABLE_ (INITIALLY_ (DEFERRED_ | IMMEDIATE_))?)? +; + +conflict_clause: + ON_ CONFLICT_ ( + ROLLBACK_ + | ABORT_ + | FAIL_ + | IGNORE_ + | REPLACE_ + ) +; + +create_trigger_stmt: + CREATE_ (TEMP_ | TEMPORARY_)? TRIGGER_ (IF_ NOT_ EXISTS_)? ( + schema_name DOT + )? trigger_name (BEFORE_ | AFTER_ | INSTEAD_ OF_)? ( + DELETE_ + | INSERT_ + | UPDATE_ (OF_ column_name ( COMMA column_name)*)? + ) ON_ table_name (FOR_ EACH_ ROW_)? (WHEN_ expr)? BEGIN_ ( + (update_stmt | insert_stmt | delete_stmt | select_stmt) SCOL + )+ END_ +; + +create_view_stmt: + CREATE_ (TEMP_ | TEMPORARY_)? VIEW_ (IF_ NOT_ EXISTS_)? ( + schema_name DOT + )? view_name (OPEN_PAR column_name (COMMA column_name)* CLOSE_PAR)? AS_ select_stmt +; + +create_virtual_table_stmt: + CREATE_ VIRTUAL_ TABLE_ (IF_ NOT_ EXISTS_)? (schema_name DOT)? table_name USING_ module_name ( + OPEN_PAR module_argument (COMMA module_argument)* CLOSE_PAR + )? +; + +with_clause: + WITH_ RECURSIVE_? cte_table_name AS_ OPEN_PAR select_stmt CLOSE_PAR ( + COMMA cte_table_name AS_ OPEN_PAR select_stmt CLOSE_PAR + )* +; + +cte_table_name: + table_name (OPEN_PAR column_name ( COMMA column_name)* CLOSE_PAR)? +; + +recursive_cte: + cte_table_name AS_ OPEN_PAR initial_select UNION_ ALL_? recursive__select CLOSE_PAR +; + +common_table_expression: + table_name (OPEN_PAR column_name ( COMMA column_name)* CLOSE_PAR)? AS_ OPEN_PAR select_stmt CLOSE_PAR +; + +delete_stmt: + with_clause? DELETE_ FROM_ qualified_table_name (WHERE_ expr)? +; + +delete_stmt_limited: + with_clause? DELETE_ FROM_ qualified_table_name (WHERE_ expr)? ( + order_by_stmt? limit_stmt + )? +; + +detach_stmt: + DETACH_ DATABASE_? schema_name +; + +drop_stmt: + DROP_ object = (INDEX_ | TABLE_ | TRIGGER_ | VIEW_) ( + IF_ EXISTS_ + )? (schema_name DOT)? any_name +; + +/* + SQLite understands the following binary operators, in order from highest to lowest precedence: + || + * / % + + - + << >> & | + < <= > >= + = == != <> IS IS NOT IN LIKE GLOB MATCH REGEXP + AND + OR + */ +expr: + literal_value + | BIND_PARAMETER + | ((schema_name DOT)? table_name DOT)? column_name + | unary_operator expr + | expr PIPE2 expr + | expr ( STAR | DIV | MOD) expr + | expr ( PLUS | MINUS) expr + | expr ( LT2 | GT2 | AMP | PIPE) expr + | expr ( LT | LT_EQ | GT | GT_EQ) expr + | expr ( + ASSIGN + | EQ + | NOT_EQ1 + | NOT_EQ2 + | IS_ + | IS_ NOT_ + | IN_ + | LIKE_ + | GLOB_ + | MATCH_ + | REGEXP_ + ) expr + | expr AND_ expr + | expr OR_ expr + | function_name OPEN_PAR ((DISTINCT_? expr ( COMMA expr)*) | STAR)? CLOSE_PAR filter_clause? over_clause? + | OPEN_PAR expr (COMMA expr)* CLOSE_PAR + | CAST_ OPEN_PAR expr AS_ type_name CLOSE_PAR + | expr COLLATE_ collation_name + | expr NOT_? (LIKE_ | GLOB_ | REGEXP_ | MATCH_) expr ( + ESCAPE_ expr + )? + | expr ( ISNULL_ | NOTNULL_ | NOT_ NULL_) + | expr IS_ NOT_? expr + | expr NOT_? BETWEEN_ expr AND_ expr + | expr NOT_? IN_ ( + OPEN_PAR (select_stmt | expr ( COMMA expr)*)? CLOSE_PAR + | ( schema_name DOT)? table_name + | (schema_name DOT)? table_function_name OPEN_PAR (expr (COMMA expr)*)? CLOSE_PAR + ) + | ((NOT_)? EXISTS_)? OPEN_PAR select_stmt CLOSE_PAR + | CASE_ expr? (WHEN_ expr THEN_ expr)+ (ELSE_ expr)? END_ + | raise_function +; + +raise_function: + RAISE_ OPEN_PAR ( + IGNORE_ + | (ROLLBACK_ | ABORT_ | FAIL_) COMMA error_message + ) CLOSE_PAR +; + +literal_value: + NUMERIC_LITERAL + | STRING_LITERAL + | BLOB_LITERAL + | NULL_ + | TRUE_ + | FALSE_ + | CURRENT_TIME_ + | CURRENT_DATE_ + | CURRENT_TIMESTAMP_ +; + +insert_stmt: + with_clause? ( + INSERT_ + | REPLACE_ + | INSERT_ OR_ ( + REPLACE_ + | ROLLBACK_ + | ABORT_ + | FAIL_ + | IGNORE_ + ) + ) INTO_ (schema_name DOT)? table_name (AS_ table_alias)? ( + OPEN_PAR column_name ( COMMA column_name)* CLOSE_PAR + )? ( + ( + VALUES_ OPEN_PAR expr (COMMA expr)* CLOSE_PAR ( + COMMA OPEN_PAR expr ( COMMA expr)* CLOSE_PAR + )* + | select_stmt + ) upsert_clause? + ) + | DEFAULT_ VALUES_ +; + +upsert_clause: + ON_ CONFLICT_ ( + OPEN_PAR indexed_column (COMMA indexed_column)* CLOSE_PAR (WHERE_ expr)? + )? DO_ ( + NOTHING_ + | UPDATE_ SET_ ( + (column_name | column_name_list) EQ expr ( + COMMA (column_name | column_name_list) EQ expr + )* (WHERE_ expr)? + ) + ) +; + +pragma_stmt: + PRAGMA_ (schema_name DOT)? pragma_name ( + ASSIGN pragma_value + | OPEN_PAR pragma_value CLOSE_PAR + )? +; + +pragma_value: + signed_number + | name + | STRING_LITERAL +; + +reindex_stmt: + REINDEX_ (collation_name | (schema_name DOT)? (table_name | index_name))? +; + +select_stmt: + common_table_stmt? select_core (compound_operator select_core)* order_by_stmt? limit_stmt? +; + +join_clause: + table_or_subquery (join_operator table_or_subquery join_constraint?)* +; + +select_core: + ( + SELECT_ (DISTINCT_ | ALL_)? result_column (COMMA result_column)* ( + FROM_ (table_or_subquery (COMMA table_or_subquery)* | join_clause) + )? (WHERE_ expr)? (GROUP_ BY_ expr (COMMA expr)* (HAVING_ expr)?)? ( + WINDOW_ window_name AS_ window_defn ( + COMMA window_name AS_ window_defn + )* + )? + ) + | VALUES_ OPEN_PAR expr (COMMA expr)* CLOSE_PAR ( + COMMA OPEN_PAR expr ( COMMA expr)* CLOSE_PAR + )* +; + +factored_select_stmt: + select_stmt +; + +simple_select_stmt: + common_table_stmt? select_core order_by_stmt? limit_stmt? +; + +compound_select_stmt: + common_table_stmt? select_core ( + (UNION_ ALL_? | INTERSECT_ | EXCEPT_) select_core + )+ order_by_stmt? limit_stmt? +; + +table_or_subquery: ( + (schema_name DOT)? table_name (AS_? table_alias)? ( + INDEXED_ BY_ index_name + | NOT_ INDEXED_ + )? + ) + | (schema_name DOT)? table_function_name OPEN_PAR expr (COMMA expr)* CLOSE_PAR ( + AS_? table_alias + )? + | OPEN_PAR (table_or_subquery (COMMA table_or_subquery)* | join_clause) CLOSE_PAR + | OPEN_PAR select_stmt CLOSE_PAR (AS_? table_alias)? +; + +result_column: + STAR + | table_name DOT STAR + | expr ( AS_? column_alias)? +; + +join_operator: + COMMA + | NATURAL_? (LEFT_ OUTER_? | INNER_ | CROSS_)? JOIN_ +; + +join_constraint: + ON_ expr + | USING_ OPEN_PAR column_name ( COMMA column_name)* CLOSE_PAR +; + +compound_operator: + UNION_ ALL_? + | INTERSECT_ + | EXCEPT_ +; + +update_stmt: + with_clause? UPDATE_ ( + OR_ (ROLLBACK_ | ABORT_ | REPLACE_ | FAIL_ | IGNORE_) + )? qualified_table_name SET_ (column_name | column_name_list) ASSIGN expr ( + COMMA (column_name | column_name_list) ASSIGN expr + )* (WHERE_ expr)? +; + +column_name_list: + OPEN_PAR column_name (COMMA column_name)* CLOSE_PAR +; + +update_stmt_limited: + with_clause? UPDATE_ ( + OR_ (ROLLBACK_ | ABORT_ | REPLACE_ | FAIL_ | IGNORE_) + )? qualified_table_name SET_ (column_name | column_name_list) ASSIGN expr ( + COMMA (column_name | column_name_list) ASSIGN expr + )* (WHERE_ expr)? (order_by_stmt? limit_stmt)? +; + +qualified_table_name: (schema_name DOT)? table_name (AS_ alias)? ( + INDEXED_ BY_ index_name + | NOT_ INDEXED_ + )? +; + +vacuum_stmt: + VACUUM_ schema_name? (INTO_ filename)? +; + +filter_clause: + FILTER_ OPEN_PAR WHERE_ expr CLOSE_PAR +; + +window_defn: + OPEN_PAR base_window_name? (PARTITION_ BY_ expr (COMMA expr)*)? ( + ORDER_ BY_ ordering_term (COMMA ordering_term)* + ) frame_spec? CLOSE_PAR +; + +over_clause: + OVER_ ( + window_name + | OPEN_PAR base_window_name? (PARTITION_ BY_ expr (COMMA expr)*)? ( + ORDER_ BY_ ordering_term (COMMA ordering_term)* + )? frame_spec? CLOSE_PAR + ) +; + +frame_spec: + frame_clause ( + EXCLUDE_ (NO_ OTHERS_) + | CURRENT_ ROW_ + | GROUP_ + | TIES_ + )? +; + +frame_clause: (RANGE_ | ROWS_ | GROUPS_) ( + frame_single + | BETWEEN_ frame_left AND_ frame_right + ) +; + +simple_function_invocation: + simple_func OPEN_PAR (expr (COMMA expr)* | STAR) CLOSE_PAR +; + +aggregate_function_invocation: + aggregate_func OPEN_PAR (DISTINCT_? expr (COMMA expr)* | STAR)? CLOSE_PAR filter_clause? +; + +window_function_invocation: + window_function OPEN_PAR (expr (COMMA expr)* | STAR)? CLOSE_PAR filter_clause? OVER_ ( + window_defn + | window_name + ) +; + +common_table_stmt: //additional structures + WITH_ RECURSIVE_? common_table_expression (COMMA common_table_expression)* +; + +order_by_stmt: + ORDER_ BY_ ordering_term (COMMA ordering_term)* +; + +limit_stmt: + LIMIT_ expr ((OFFSET_ | COMMA) expr)? +; + +ordering_term: + expr (COLLATE_ collation_name)? asc_desc? (NULLS_ (FIRST_ | LAST_))? +; + +asc_desc: + ASC_ + | DESC_ +; + +frame_left: + expr PRECEDING_ + | expr FOLLOWING_ + | CURRENT_ ROW_ + | UNBOUNDED_ PRECEDING_ +; + +frame_right: + expr PRECEDING_ + | expr FOLLOWING_ + | CURRENT_ ROW_ + | UNBOUNDED_ FOLLOWING_ +; + +frame_single: + expr PRECEDING_ + | UNBOUNDED_ PRECEDING_ + | CURRENT_ ROW_ +; + +// unknown + +window_function: + (FIRST_VALUE_ | LAST_VALUE_) OPEN_PAR expr CLOSE_PAR OVER_ OPEN_PAR partition_by? order_by_expr_asc_desc frame_clause + ? CLOSE_PAR + | (CUME_DIST_ | PERCENT_RANK_) OPEN_PAR CLOSE_PAR OVER_ OPEN_PAR partition_by? order_by_expr? CLOSE_PAR + | (DENSE_RANK_ | RANK_ | ROW_NUMBER_) OPEN_PAR CLOSE_PAR OVER_ OPEN_PAR partition_by? order_by_expr_asc_desc + CLOSE_PAR + | (LAG_ | LEAD_) OPEN_PAR expr of_OF_fset? default_DEFAULT__value? CLOSE_PAR OVER_ OPEN_PAR partition_by? + order_by_expr_asc_desc CLOSE_PAR + | NTH_VALUE_ OPEN_PAR expr COMMA signed_number CLOSE_PAR OVER_ OPEN_PAR partition_by? order_by_expr_asc_desc + frame_clause? CLOSE_PAR + | NTILE_ OPEN_PAR expr CLOSE_PAR OVER_ OPEN_PAR partition_by? order_by_expr_asc_desc CLOSE_PAR +; + +of_OF_fset: + COMMA signed_number +; + +default_DEFAULT__value: + COMMA signed_number +; + +partition_by: + PARTITION_ BY_ expr+ +; + +order_by_expr: + ORDER_ BY_ expr+ +; + +order_by_expr_asc_desc: + ORDER_ BY_ order_by_expr_asc_desc +; + +expr_asc_desc: + expr asc_desc? (COMMA expr asc_desc?)* +; + +//TODO BOTH OF THESE HAVE TO BE REWORKED TO FOLLOW THE SPEC +initial_select: + select_stmt +; + +recursive__select: + select_stmt +; + +unary_operator: + MINUS + | PLUS + | TILDE + | NOT_ +; + +error_message: + STRING_LITERAL +; + +module_argument: // TODO check what exactly is permitted here + expr + | column_def +; + +column_alias: + IDENTIFIER + | STRING_LITERAL +; + +keyword: + ABORT_ + | ACTION_ + | ADD_ + | AFTER_ + | ALL_ + | ALTER_ + | ANALYZE_ + | AND_ + | AS_ + | ASC_ + | ATTACH_ + | AUTOINCREMENT_ + | BEFORE_ + | BEGIN_ + | BETWEEN_ + | BY_ + | CASCADE_ + | CASE_ + | CAST_ + | CHECK_ + | COLLATE_ + | COLUMN_ + | COMMIT_ + | CONFLICT_ + | CONSTRAINT_ + | CREATE_ + | CROSS_ + | CURRENT_DATE_ + | CURRENT_TIME_ + | CURRENT_TIMESTAMP_ + | DATABASE_ + | DEFAULT_ + | DEFERRABLE_ + | DEFERRED_ + | DELETE_ + | DESC_ + | DETACH_ + | DISTINCT_ + | DROP_ + | EACH_ + | ELSE_ + | END_ + | ESCAPE_ + | EXCEPT_ + | EXCLUSIVE_ + | EXISTS_ + | EXPLAIN_ + | FAIL_ + | FOR_ + | FOREIGN_ + | FROM_ + | FULL_ + | GLOB_ + | GROUP_ + | HAVING_ + | IF_ + | IGNORE_ + | IMMEDIATE_ + | IN_ + | INDEX_ + | INDEXED_ + | INITIALLY_ + | INNER_ + | INSERT_ + | INSTEAD_ + | INTERSECT_ + | INTO_ + | IS_ + | ISNULL_ + | JOIN_ + | KEY_ + | LEFT_ + | LIKE_ + | LIMIT_ + | MATCH_ + | NATURAL_ + | NO_ + | NOT_ + | NOTNULL_ + | NULL_ + | OF_ + | OFFSET_ + | ON_ + | OR_ + | ORDER_ + | OUTER_ + | PLAN_ + | PRAGMA_ + | PRIMARY_ + | QUERY_ + | RAISE_ + | RECURSIVE_ + | REFERENCES_ + | REGEXP_ + | REINDEX_ + | RELEASE_ + | RENAME_ + | REPLACE_ + | RESTRICT_ + | RIGHT_ + | ROLLBACK_ + | ROW_ + | ROWS_ + | SAVEPOINT_ + | SELECT_ + | SET_ + | TABLE_ + | TEMP_ + | TEMPORARY_ + | THEN_ + | TO_ + | TRANSACTION_ + | TRIGGER_ + | UNION_ + | UNIQUE_ + | UPDATE_ + | USING_ + | VACUUM_ + | VALUES_ + | VIEW_ + | VIRTUAL_ + | WHEN_ + | WHERE_ + | WITH_ + | WITHOUT_ + | FIRST_VALUE_ + | OVER_ + | PARTITION_ + | RANGE_ + | PRECEDING_ + | UNBOUNDED_ + | CURRENT_ + | FOLLOWING_ + | CUME_DIST_ + | DENSE_RANK_ + | LAG_ + | LAST_VALUE_ + | LEAD_ + | NTH_VALUE_ + | NTILE_ + | PERCENT_RANK_ + | RANK_ + | ROW_NUMBER_ + | GENERATED_ + | ALWAYS_ + | STORED_ + | TRUE_ + | FALSE_ + | WINDOW_ + | NULLS_ + | FIRST_ + | LAST_ + | FILTER_ + | GROUPS_ + | EXCLUDE_ +; + +// TODO: check all names below + +name: + any_name +; + +function_name: + any_name +; + +schema_name: + any_name +; + +table_name: + any_name +; + +table_or_index_name: + any_name +; + +new_table_name: + any_name +; + +column_name: + any_name +; + +collation_name: + any_name +; + +foreign_table: + any_name +; + +index_name: + any_name +; + +trigger_name: + any_name +; + +view_name: + any_name +; + +module_name: + any_name +; + +pragma_name: + any_name +; + +savepoint_name: + any_name +; + +table_alias: + any_name +; + +transaction_name: + any_name +; + +window_name: + any_name +; + +alias: + any_name +; + +filename: + any_name +; + +base_window_name: + any_name +; + +simple_func: + any_name +; + +aggregate_func: + any_name +; + +table_function_name: + any_name +; + +any_name: + IDENTIFIER + | keyword + | STRING_LITERAL + | OPEN_PAR any_name CLOSE_PAR +; diff --git a/Test/Test.Shared/Test.Shared.projitems b/Test/Test.Shared/Test.Shared.projitems new file mode 100644 index 0000000..ec0f731 --- /dev/null +++ b/Test/Test.Shared/Test.Shared.projitems @@ -0,0 +1,27 @@ + + + + $(MSBuildAllProjects);$(MSBuildThisFileFullPath) + true + ed8baf15-5b0b-4027-9b23-dd14b24739db + + + Test.Shared + + + + Always + + + Always + + + Always + + + + + + + + \ No newline at end of file diff --git a/Tests.Shared/Tests.Shared.shproj b/Test/Test.Shared/Test.Shared.shproj similarity index 87% rename from Tests.Shared/Tests.Shared.shproj rename to Test/Test.Shared/Test.Shared.shproj index ff630d8..8886d1d 100644 --- a/Tests.Shared/Tests.Shared.shproj +++ b/Test/Test.Shared/Test.Shared.shproj @@ -1,13 +1,13 @@ - 20337a6c-c920-43c8-8b34-665d91eadf89 + ed8baf15-5b0b-4027-9b23-dd14b24739db 14.0 - + diff --git a/Test/Test.Shared/TestContainer.cs b/Test/Test.Shared/TestContainer.cs new file mode 100644 index 0000000..3b87be4 --- /dev/null +++ b/Test/Test.Shared/TestContainer.cs @@ -0,0 +1,60 @@ +using System; +using System.Linq; +using Xunit; +using static ZSpitz.Util.Functions; +using Antlr4.Runtime; +using ZSpitz.Util; +using Antlr4.Runtime.Tree; +using ParseTreeVisualizer.Serialization; +using static System.IO.File; + +namespace ParseTreeVisualizer.Test { + public class TestContainer { + public static readonly TheoryData TestData = IIFE(() => { + var filesLexersParsers = new[] { + IIFE(() => { + var parserType = typeof(SQLiteParser); + return ( + "WindowsFunctionsForSqLite.sql", + typeof(SQLiteLexer), + parserType, + parserType.GetMethod(nameof(SQLiteParser.parse))! + ); + }) + }; + + var sources = filesLexersParsers.SelectManyT((filename, lexerType, parserType, parseMethod) => { + var source = ReadAllText(filename); + var input = new AntlrInputStream(source); + var lexer = lexerType.CreateInstance(new[] { input }); + var tokens = new CommonTokenStream(lexer); + var parser = parserType.CreateInstance(new[] { tokens }); + var tree = (IParseTree)parseMethod.Invoke(parser, Array.Empty())!; + return new object[] { + source, tokens, tree + }.Select(x => ( + source: x, + lexerName: lexerType.Name, + parserName: parserType.Name, + parseMethodName: parseMethod.Name + )); + }).ToList(); + + return sources.SelectManyT((source, lexerName, parserName, parseMethodName) => { + var configs = Enumerable.Range(0, 4).Select(x => new Config()).ToArray(); + configs.Skip(1).ForEach(x => x.SelectedLexerName = lexerName); + configs.Skip(2).ForEach(x => x.SelectedParserName = parserName); + configs.Skip(3).ForEach(x => x.ParseTokensWithRule = parseMethodName); + return configs.Select(config => (source, config)); + }).ToTheoryData(); + }); + + [Theory] + [MemberData(nameof(TestData))] + public void TestMethod(object source, Config config) { + var vd = new VisualizerData(source, config); + _ = new ConfigViewModel(vd); + _ = new VisualizerDataViewModel(vd, null, null, null); + } + } +} diff --git a/Test/Test.Shared/WindowsFunctionsForSqLite.sql b/Test/Test.Shared/WindowsFunctionsForSqLite.sql new file mode 100644 index 0000000..286809c --- /dev/null +++ b/Test/Test.Shared/WindowsFunctionsForSqLite.sql @@ -0,0 +1,301 @@ +SELECT + Name, + printf('%,d',Bytes) Size, + FIRST_VALUE(Name) OVER ( + ORDER BY Bytes + ) AS SmallestTrack +FROM + tracks +WHERE + AlbumId = 1; + +SELECT + AlbumId, + Name, + printf('%,d',Bytes) Size, + FIRST_VALUE(Name) OVER ( + PARTITION BY AlbumId + ORDER BY Bytes DESC + ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING + ) AS LargestTrack +FROM + tracks; +select * from COMPANY; + +SELECT C.ID, C.NAME, C.AGE, D.DEPT + FROM COMPANY AS C, DEPARTMENT AS D + WHERE C.ID = D.EMP_ID; + +SELECT C.ID AS COMPANY_ID, C.NAME AS COMPANY_NAME, C.AGE, D.DEPT + FROM COMPANY AS C, DEPARTMENT AS D + WHERE C.ID = D.EMP_ID; + +SELECT + Value, + CUME_DIST() + OVER ( + ORDER BY value + ) CumulativeDistribution +FROM + CumeDistDemo; +SELECT + Val, + DENSE_RANK () OVER ( + ORDER BY Val ) + ValRank +FROM + DenseRankDemo; + + +SELECT + CustomerId, + Year, + Total, + LAG ( Total, 1, 0 ) OVER ( + ORDER BY Year + ) PreviousYearTotal +FROM + CustomerInvoices +WHERE + CustomerId = 4; + +SELECT + CustomerId, + Year, + Total, + LAG ( Total,1,0) OVER ( + PARTITION BY CustomerId + ORDER BY Year ) PreviousYearTotal +FROM + CustomerInvoices; + + +SELECT + Name, + printf ( '%.f minutes', + Milliseconds / 1000 / 60 ) + AS Length, + LAST_VALUE ( Name ) OVER ( + ORDER BY Milliseconds + RANGE BETWEEN UNBOUNDED PRECEDING AND + UNBOUNDED FOLLOWING + ) AS LongestTrack +FROM + tracks +WHERE + AlbumId = 4; + + +SELECT + AlbumId, + Name, + printf ( '%.f minutes', + Milliseconds / 1000 / 60 ) + AS Length, + LAST_VALUE ( Name ) OVER ( + PARTITION BY AlbumId + ORDER BY Milliseconds DESC + RANGE BETWEEN UNBOUNDED PRECEDING AND + UNBOUNDED FOLLOWING + ) AS ShortestTrack +FROM + tracks; + +SELECT + CustomerId, + Year, + Total, + LEAD ( Total,1,0) OVER ( ORDER BY Year ) NextYearTotal +FROM + CustomerInvoices +WHERE + CustomerId = 1; + +SELECT + CustomerId, + Year, + Total, + LEAD ( Total, 1, 0 ) OVER ( + PARTITION BY CustomerId + ORDER BY Year + ) NextYearTotal +FROM + CustomerInvoices; + +SELECT + AlbumId, + Name, + Milliseconds Length, + NTH_VALUE ( Name,2 ) OVER ( + PARTITION BY AlbumId + ORDER BY Milliseconds DESC + RANGE BETWEEN + UNBOUNDED PRECEDING AND + UNBOUNDED FOLLOWING + ) AS SecondLongestTrack +FROM + tracks; + +SELECT + Name, + Milliseconds Length, + NTH_VALUE(name,2) OVER ( + ORDER BY Milliseconds DESC + ) SecondLongestTrack +FROM + tracks; + +SELECT + Name, + Milliseconds, + NTILE ( 4 ) OVER ( + ORDER BY Milliseconds ) LengthBucket +FROM + tracks +WHERE + AlbumId = 1; + +SELECT + AlbumId, + Name, + Milliseconds, + NTILE ( 3 ) OVER ( + PARTITION BY AlbumId + ORDER BY Bytes ) SizeBucket +FROM + tracks; + +SELECT + Name, + Milliseconds, + PERCENT_RANK() OVER( + ORDER BY Milliseconds + ) LengthPercentRank +FROM + tracks +WHERE + AlbumId = 1; + +SELECT + Name, + Milliseconds, + printf('%.2f',PERCENT_RANK() OVER( + ORDER BY Milliseconds + )) LengthPercentRank +FROM + tracks +WHERE + AlbumId = 1; + +SELECT + AlbumId, + Name, + Bytes, + printf('%.2f',PERCENT_RANK() OVER( + PARTITION BY AlbumId + ORDER BY Bytes + )) SizePercentRank +FROM + tracks; + +SELECT + Val, + RANK () OVER ( + ORDER BY Val + ) ValRank +FROM + RankDemo; + +SELECT + Name, + Milliseconds, + RANK () OVER ( + ORDER BY Milliseconds DESC + ) LengthRank +FROM + tracks; + +SELECT + Name, + Milliseconds, + AlbumId, + RANK () OVER ( + PARTITION BY AlbumId + ORDER BY Milliseconds DESC + ) LengthRank +FROM + tracks; + + +SELECT + * +FROM ( + SELECT + Name, + Milliseconds, + AlbumId, + RANK () OVER ( + PARTITION BY AlbumId + ORDER BY Milliseconds DESC + ) LengthRank + FROM + tracks +) +WHERE + LengthRank = 2; + +SELECT + ROW_NUMBER () OVER ( + ORDER BY Country + ) RowNum, + FirstName, + LastName, + country +FROM + customers; + +SELECT + ROW_NUMBER () OVER ( + PARTITION BY Country + ORDER BY FirstName + ) RowNum, + FirstName, + LastName, + country +FROM + customers; + +SELECT * FROM ( + SELECT + ROW_NUMBER () OVER ( + ORDER BY FirstName + ) RowNum, + FirstName, + LastName, + Country + FROM + customers +) t +WHERE + RowNum > 20 AND RowNum <= 30; + + +SELECT + Country, + FirstName, + LastName, + Amount +FROM ( + SELECT + Country, + FirstName, + LastName, + Amount, + ROW_NUMBER() OVER ( + PARTITION BY country + ORDER BY Amount DESC + ) RowNum + FROM + Sales ) +WHERE + RowNum = 1; \ No newline at end of file diff --git a/Test/Test.Standard/Test.Standard.csproj b/Test/Test.Standard/Test.Standard.csproj new file mode 100644 index 0000000..9c5d708 --- /dev/null +++ b/Test/Test.Standard/Test.Standard.csproj @@ -0,0 +1,44 @@ + + + + net5.0-windows + ParseTreeVisualizer.Test + true + false + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + all + + + + + + false + false + ParseTreeVisualizer.Test + + + + false + false + ParseTreeVisualizer.Test + + + + + + + diff --git a/Tests.Runtime.Standard/FormatterTest.java b/Tests.Runtime.Standard/FormatterTest.java deleted file mode 100644 index 464d4d3..0000000 --- a/Tests.Runtime.Standard/FormatterTest.java +++ /dev/null @@ -1,4262 +0,0 @@ -/* 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 deleted file mode 100644 index 38c279e..0000000 --- a/Tests.Runtime.Standard/Java9/Java9Lexer.cs +++ /dev/null @@ -1,1244 +0,0 @@ -//------------------------------------------------------------------------------ -// -// 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 deleted file mode 100644 index 504672a..0000000 --- a/Tests.Runtime.Standard/Java9/Java9Parser.cs +++ /dev/null @@ -1,22060 +0,0 @@ -//------------------------------------------------------------------------------ -// -// 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 deleted file mode 100644 index c2d1b12..0000000 --- a/Tests.Runtime.Standard/Java9/Java9ParserBaseListener.cs +++ /dev/null @@ -1,2990 +0,0 @@ -//------------------------------------------------------------------------------ -// -// 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 deleted file mode 100644 index 69e5ebd..0000000 --- a/Tests.Runtime.Standard/Java9/Java9ParserBaseVisitor.cs +++ /dev/null @@ -1,2486 +0,0 @@ -//------------------------------------------------------------------------------ -// -// 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 deleted file mode 100644 index ac65951..0000000 --- a/Tests.Runtime.Standard/Java9/Java9ParserListener.cs +++ /dev/null @@ -1,2483 +0,0 @@ -//------------------------------------------------------------------------------ -// -// 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 deleted file mode 100644 index 05eb472..0000000 --- a/Tests.Runtime.Standard/Java9/Java9ParserVisitor.cs +++ /dev/null @@ -1,1504 +0,0 @@ -//------------------------------------------------------------------------------ -// -// 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 deleted file mode 100644 index 1153b4b..0000000 --- a/Tests.Runtime.Standard/Simple.java +++ /dev/null @@ -1,57 +0,0 @@ -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 deleted file mode 100644 index 75df8d9..0000000 --- a/Tests.Runtime.Standard/TestContainer.cs +++ /dev/null @@ -1,19 +0,0 @@ -using System.IO; - -namespace ParseTreeVisualizer.Tests { - public partial class TestContainer { - static TestContainer() { - //inputs = new[] { "Simple.java", "FormatterTest.java" }.Select(x => File.ReadAllText(x)).ToArray(); - - var text = File.ReadAllText("Simple.java"); - inputs = new[] { - text, - text.Substring(0,200) - }; - - 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 deleted file mode 100644 index 6207edc..0000000 --- a/Tests.Runtime.Standard/Tests.Runtime.Standard.csproj +++ /dev/null @@ -1,32 +0,0 @@ - - - - net472;netcoreapp3.0 - 9.0 - enable - ParseTreeVisualizer.Tests - true - - - - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - - - - Always - - - Always - - - - - - diff --git a/Tests.Runtime/BasicModule(edited).bas b/Tests.Runtime/BasicModule(edited).bas deleted file mode 100644 index 79f7970..0000000 --- a/Tests.Runtime/BasicModule(edited).bas +++ /dev/null @@ -1,4968 +0,0 @@ -Attribute VB_Name = "BasicModule" -'*************************************************************************** -'* Woobind Network Meter * -'*************************************************************************** -'* Copyright (C) 2007 by Roman Gemini * -'* networkmeter@ukr.net * -'* * -'* This program is free software; you can redistribute it and/or modify * -'* it under the terms of the GNU General Public License as published by * -'* the Free Software Foundation; either version 2 of the License, or * -'* (at your option) any later version. * -'* * -'* This program is distributed in the hope that it will be useful, * -'* but WITHOUT ANY WARRANTY; without even the implied warranty of * -'* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * -'* GNU General Public License for more details. * -'* * -'* You should have received a copy of the GNU General Public License * -'* along with this program; if not, write to the * -'* Free Software Foundation, Inc., * -'* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * -'*************************************************************************** - -Public Declare Function CreateEllipticRgn Lib "gdi32" (ByVal X1 As Long, ByVal Y1 As Long, ByVal X2 As Long, ByVal Y2 As Long) As Long -Public Declare Function CreateRoundRectRgn Lib "gdi32" (ByVal X1 As Long, ByVal Y1 As Long, ByVal X2 As Long, ByVal Y2 As Long, ByVal X3 As Long, ByVal Y3 As Long) As Long -Public Declare Function StretchBlt Lib "gdi32" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal nSrcWidth As Long, ByVal nSrcHeight As Long, ByVal dwRop As Long) As Long - -Public Const WM_CLOSE = &H10 -Public Declare Function FindWindow Lib "user32" Alias "FindWindowA" (ByVal lpClassName As String, ByVal lpWindowName As String) As Long -Public Declare Sub InitCommonControls Lib "comctl32.dll" () -Public Declare Sub InitCommonControlsX Lib "mscomctl.dll" () -Public Declare Function GetWindowText Lib "user32" Alias "GetWindowTextA" (ByVal hWnd As Long, ByVal lpString As String, ByVal cch As Long) As Long -Public Declare Function FindWindowEx Lib "user32" Alias "FindWindowExA" (ByVal hWnd1 As Long, ByVal hWnd2 As Long, ByVal lpsz1 As String, ByVal lpsz2 As String) As Long -Public Declare Function GetParent Lib "user32" (ByVal hWnd As Long) As Long -Public Declare Function CreateWindowEx Lib "user32" Alias "CreateWindowExA" (ByVal dwExStyle As Long, ByVal lpClassName As String, ByVal lpWindowName As String, ByVal dwStyle As Long, ByVal x As Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hWndParent As Long, ByVal hMenu As Long, ByVal hInstance As Long, lpParam As Any) As Long -Public Declare Function Putfocus Lib "user32" Alias "SetFocus" (ByVal hWnd As Long) As Long -Public Declare Function GetForegroundWindow Lib "user32" () As Long -Public Declare Function CreateRectRgn Lib "gdi32" (ByVal X1 As Long, ByVal Y1 As Long, ByVal X2 As Long, ByVal Y2 As Long) As Long - -Private Const SND_NOSTOP = &H10 -Public Const SPI_GETWORKAREA = 48 -Public Const SPI_SETWORKAREA = 47 - - -Public Const HWND_TOPMOST = -1 -Public Const HWND_NOTOPMOST = -2 -Public Const SWP_NOACTIVATE = &H10 -Public Const SWP_SHOWWINDOW = &H40 - -Public Declare Function ExtractAssociatedIcon Lib "shell32.dll" Alias "ExtractAssociatedIconA" (ByVal hInst As Long, ByVal lpIconPath As String, lpiIcon As Long) As Long -Public Declare Function CallWindowProc Lib "user32" Alias "CallWindowProcA" (ByVal lpPrevWndFunc As Long, ByVal hWnd As Long, ByVal Msg As Long, ByVal wParam As Long, ByVal lParam As Long) As Long -Public Declare Function PostMessage Lib "user32" Alias "PostMessageA" (ByVal hWnd As Long, ByVal wMsg As Long, ByVal wParam As Long, ByVal lParam As Long) As Long -Public Declare Function VarPtrArray Lib "msvbvm60.dll" Alias "VarPtr" (Ptr() As Any) As Long -Public Declare Function PeekMessage Lib "user32" Alias "PeekMessageA" (lpMsg As Msg, ByVal hWnd As Long, ByVal wMsgFilterMin As Long, ByVal wMsgFilterMax As Long, ByVal wRemoveMsg As Long) As Long -Public Declare Function lstrcpyn1 Lib "kernel32" Alias "lstrcpynA" (lpString1 As Byte, ByVal lpString2 As String, ByVal cNumber As Long) As Long -Public Declare Function lstrcpyn2 Lib "kernel32" Alias "lstrcpynA" (ByVal lpString1 As String, lpString2 As Byte, ByVal cNumber As Long) As Long -Public Declare Function SystemTimer Lib "winmm.dll" Alias "timeGetTime" () As Long -Public Declare Function GetTempPath Lib "kernel32" Alias "GetTempPathA" (ByVal nBufferLength As Long, ByVal lpBuffer As String) As Long -Public Declare Function SetWindowPos Lib "user32" (ByVal hWnd As Long, ByVal hWndInsertAfter As Long, ByVal x As Long, ByVal y As Long, ByVal cx As Long, ByVal cy As Long, ByVal wFlags As Long) As Long -Public Declare Function ShellExecute Lib "shell32.dll" Alias "ShellExecuteA" (ByVal hWnd As Long, ByVal lpOperation As String, ByVal lpFile As String, ByVal lpParameters As String, ByVal lpDirectory As String, ByVal nShowCmd As Long) As Long -Public Declare Function GetWindowsVersion Lib "kernel32" Alias "GetVersion" () As Long -Public Declare Function RegisterServiceProcess Lib "kernel32.dll" (ByVal dwProcessId As Long, ByVal dwType As Long) As Long -Public Declare Function GetCurrentProcessId Lib "kernel32.dll" () As Long -Public Declare Function SetWindowLong Lib "user32" Alias "SetWindowLongA" (ByVal hWnd As Long, ByVal nIndex As Long, ByVal dwNewLong As Long) As Long -Public Declare Function GetWindowLong Lib "user32" Alias "GetWindowLongA" (ByVal hWnd As Long, ByVal nIndex As Long) As Long -Public Declare Function RegQueryValueEx Lib "advapi32" Alias "RegQueryValueExA" (ByVal hKey As Long, ByVal lpValueName As String, lpReserved As Long, lpType As Long, lpData As Any, lpcbData As Long) As Long -Public Declare Function RegOpenKeyEx Lib "advapi32" Alias "RegOpenKeyExA" (ByVal hKey&, ByVal lpSubKey$, ByVal dwReserved&, ByVal samDesired As Long, phkResult As Long) As Long -Public Declare Function RegCreateKey Lib "advapi32.dll" Alias "RegCreateKeyA" (ByVal hKey As Long, ByVal lpSubKey As String, phkResult As Long) As Long -Public Declare Function RegSetValueEx Lib "advapi32.dll" Alias "RegSetValueExA" (ByVal hKey As Long, ByVal lpValueName As String, ByVal Reserved As Long, ByVal dwType As Long, lpData As Any, ByVal cbData As Long) As Long -Public Declare Function RegCloseKey Lib "advapi32.dll" (ByVal hKey As Long) As Long -Public Declare Function ExtFloodFill Lib "gdi32" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal crColor As Long, ByVal wFillType As Long) As Long -Public Declare Function Beep Lib "kernel32" (ByVal dwFreq As Long, ByVal dwDuration As Long) As Long -Public Declare Sub Sleep Lib "kernel32" (ByVal milliseconds As Long) -Public Declare Function SetParent Lib "user32" (ByVal hWndChild As Long, ByVal hWndNewParent As Long) As Long -Public Declare Function GetDesktopWindow Lib "user32" () As Long -Public Declare Function GetSystemDirectory Lib "kernel32" Alias "GetSystemDirectoryA" (ByVal lpBuffer As String, ByVal nSize As Long) As Long -Public Declare Function sndPlaySound Lib "winmm.dll" Alias "sndPlaySoundA" (ByVal lpszSoundName As String, ByVal uFlags As Long) As Long -Public Declare Function sndStopSound Lib "winmm.dll" Alias "sndPlaySoundA" (ByVal lpszNull As Long, ByVal uFlags As Long) As Long -Public Declare Function GetDiskFreeSpaceEx Lib "kernel32" Alias "GetDiskFreeSpaceExA" (ByVal lpDirectoryName As String, lpFreeBytesAvailableToCaller As Currency, lpTotalNumberOfBytes As Currency, lpTotalNumberOfFreeBytes As Currency) As Long -Public Declare Function SetWindowRgn Lib "user32" (ByVal hWnd As Long, ByVal hRgn As Long, ByVal bRedraw As Boolean) As Long -Public Declare Function CreatePolygonRgn Lib "gdi32" (lpPoint As POINTAPI, ByVal nCount As Long, ByVal nPolyFillMode As Long) As Long -Public Declare Function GetFileAttributes Lib "kernel32" Alias "GetFileAttributesA" (ByVal lpFileName As String) As Long -Public Declare Function GetShortPathName Lib "kernel32" Alias "GetShortPathNameA" (ByVal lpszLongPath As String, ByVal lpszShortPath As String, ByVal cchBuffer As Long) As Long -Public Declare Function GetPixel Lib "gdi32" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long) As Long -Public Declare Function SetPixelV Lib "gdi32" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal crColor As Long) As Long -Public Declare Function PtInRegion Lib "gdi32" (ByVal hRgn As Long, ByVal x As Long, ByVal y As Long) As Long -Public Declare Function GetWindowRgn Lib "user32" (ByVal hWnd As Long, ByVal hRgn As Long) As Long -Public Declare Function LineTo Lib "gdi32" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long) As Long -Public Declare Function MoveToEx Lib "gdi32" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, lpPoint As POINTAPI) As Long -Public Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (ByRef Destination As Any, ByRef Source As Any, ByVal Length As Long) -Public Declare Function BitBlt Lib "gdi32" (ByVal hDestDC As Long, ByVal x As Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal dwRop As Long) As Long - -Public Declare Function TransparentBlt Lib "gdi32" Alias "GdiTransparentBlt" (ByVal hDestDC As Long, ByVal x As Long, ByVal y As Long, ByVal nWidthDest As Long, ByVal nHeightDest As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal nWidthSrc As Long, ByVal nHeightSrc As Long, ByVal crTransparent As Long) As Long -Public Declare Function AlphaBlend Lib "gdi32" Alias "GdiAlphaBlend" (ByVal hDestDC As Long, ByVal x As Long, ByVal y As Long, ByVal nWidthDest As Long, ByVal nHeightDest As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal nWidthSrc As Long, ByVal nHeightSrc As Long, pblendFunction As blendFunction) As Long -Public Declare Function AlphaBlendA Lib "gdi32" Alias "GdiAlphaBlend" (ByVal hDestDC As Long, ByVal x As Long, ByVal y As Long, ByVal nWidthDest As Long, ByVal nHeightDest As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal nWidthSrc As Long, ByVal nHeightSrc As Long, pblendFunction As Any) As Long - - - -Public Declare Function GetKeyState Lib "user32" (ByVal nVirtKey As Long) As Integer -Public Declare Function SHGetFileInfo Lib "shell32" Alias "SHGetFileInfoA" (ByVal pszPath As Any, ByVal dwFileAttributes As Long, psfi As SHFILEINFO, ByVal cbFileInfo As Long, ByVal uFlags As Long) As Long -Public Declare Function DrawIconEx Lib "user32" (ByVal hdc As Long, ByVal xLeft As Long, ByVal yTop As Long, ByVal hIcon As Long, ByVal cxWidth As Long, ByVal cyWidth As Long, ByVal istepIfAniCur As Long, ByVal hbrFlickerFreeDraw As Long, ByVal diFlags As Long) As Boolean -Public Declare Function DestroyIcon Lib "user32" (ByVal hIcon As Long) As Long -Public Declare Function ImageList_GetIconSize Lib "comctl32" (ByVal himl As Long, cx As Long, cy As Long) As Boolean -Public Declare Function OpenProcess Lib "kernel32" (ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, ByVal dwProcessId As Long) As Long -Public Declare Function TerminateProcess Lib "kernel32" (ByVal hProcess As Long, ByVal uExitCode As Long) As Long -Public Declare Function GetWindowThreadProcessId Lib "user32" (ByVal hWnd As Long, lpdwProcessId As Long) As Long -Public Declare Function CreateSolidBrush Lib "gdi32" (ByVal crColor As Long) As Long -Public Declare Function FillRect Lib "user32" (ByVal hdc As Long, lpRect As RECT, ByVal hBrush As Long) As Long -Public Declare Function GetWindowRect Lib "user32" (ByVal hWnd As Long, lpRect As RECT) As Long -Public Declare Function ClientToScreen Lib "user32" (ByVal hWnd As Long, lpPoint As POINTAPI) As Long -Public Declare Sub FillMemory Lib "kernel32" Alias "RtlFillMemory" (Destination As Any, ByVal Length As Long, ByVal FillData As Byte) -Public Declare Function OleCreatePictureIndirect Lib "olepro32.dll" (lpPictDesc As PictDesc, riid As Guid, ByVal fOwn As Long, iPic As IPicture) As Long -Public Declare Function CopyIcon Lib "user32" (ByVal hIcon As Long) As Long -'Public Declare Function DrawIconEx Lib "user32" (ByVal hdc As Long, ByVal xLeft As Long, ByVal yTop As Long, ByVal hIcon As Long, ByVal cxWidth As Long, ByVal cyHeight As Long, ByVal istepIfAniCur As Long, ByVal hbrFlickerFreeDraw As Long, ByVal diFlags As Long) As Long -Public Declare Function DrawIcon Lib "user32.dll" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal hIcon As Long) -Public Declare Function timeGetTime Lib "winmm.dll" () As Long -Public Declare Function SetPriorityClass Lib "kernel32" (ByVal hProcess As Long, ByVal dwPriorityClass As Long) As Long -Public Declare Function SetThreadPriority Lib "kernel32" (ByVal hThread As Long, ByVal nPriority As Long) As Long -Public Declare Function GetFullPathName Lib "kernel32" Alias "GetFullPathNameA" (ByVal lpFileName As String, ByVal nBufferLength As Long, ByVal lpBuffer As String, ByVal lpFilePart As String) As Long -Public Declare Function GetCursorPos Lib "user32" (cPoint As POINTAPI) As Long -Public Declare Function WindowFromPoint Lib "user32" (ByVal xPoint As Long, ByVal yPoint As Long) As Long -Public Declare Function Shell_NotifyIcon Lib "shell32.dll" Alias "Shell_NotifyIconA" (ByVal dwMessage As Long, lpData As NOTIFYICONDATA) As Long -Public Declare Function GetObjectAPI Lib "gdi32" Alias "GetObjectA" (ByVal hObject As Long, ByVal nCount As Long, lpObject As Any) As Long -Public Declare Function GetObjectA Lib "gdi32" (ByVal hObject As Long, ByVal nCount As Long, lpObject As Any) As Long -Public Declare Function GetUserName Lib "advapi32.dll" Alias "GetUserNameA" (ByVal lpBuffer As String, nSize As Long) As Long -Public Declare Function SendMessage Lib "user32" Alias "SendMessageA" (ByVal hWnd As Long, ByVal wMsg As Long, ByVal wParam As Long, lParam As Any) As Long -Public Declare Function DefWindowProc Lib "user32" Alias "DefWindowProcA" (ByVal hWnd As Long, ByVal wMsg As Long, ByVal wParam As Long, ByVal lParam As Long) As Long -Public Declare Function GetClientRect Lib "user32" (ByVal hWnd As Long, lpRect As RECT) As Long -Public Declare Function GetIconInfo Lib "user32" (ByVal hIcon As Long, piconinfo As ICONINFO) As Long -Public Declare Function CreateBitmap Lib "gdi32" (ByVal nWidth As Long, ByVal nHeight As Long, ByVal nPlanes As Long, ByVal nBitCount As Long, lpBits As Any) As Long -Public Declare Function CopyImage Lib "user32" (ByVal handle As Long, ByVal uType As Long, ByVal cxDesired As Long, ByVal cyDesired As Long, ByVal fuFlags As Long) As Long -Public Declare Function CreateCompatibleDC Lib "gdi32" (ByVal hdc As Long) As Long -Public Declare Function SelectObject Lib "gdi32" (ByVal hdc As Long, ByVal hObject As Long) As Long -Public Declare Function SetBkColor Lib "gdi32" (ByVal hdc As Long, ByVal crColor As Long) As Long -Public Declare Function SetTextColor Lib "gdi32" (ByVal hdc As Long, ByVal crColor As Long) As Long -Public Declare Function GetBkColor Lib "gdi32" (ByVal hdc As Long) As Long -Public Declare Function GetTextColor Lib "gdi32" (ByVal hdc As Long) As Long -Public Declare Function DeleteDC Lib "gdi32" (ByVal hdc As Long) As Long -Public Declare Function DeleteObject Lib "gdi32" (ByVal hObject As Long) As Long -Public Declare Function OleTranslateColor Lib "oleaut32.dll" (ByVal lOleColor As Long, ByVal lHPalette As Long, lColorRef As Long) As Long -Public Declare Function CreateHalftonePalette Lib "gdi32" (ByVal hdc As Long) As Long -Public Declare Function GetDC Lib "user32" (ByVal hWnd As Long) As Long -Public Declare Function ReleaseDC Lib "user32" (ByVal hWnd As Long, ByVal hdc As Long) As Long -Public Declare Function CreateDIBSection Lib "gdi32" (ByVal hdc As Long, pBitmapInfo As BITMAPINFO, ByVal un As Long, lplpVoid As Long, ByVal handle As Long, ByVal dw As Long) As Long -Public Declare Function DispatchMessage Lib "user32" Alias "DispatchMessageA" (lpMsg As Msg) As Long -Public Declare Function TranslateMessage Lib "user32" (lpMsg As Msg) As Long -Public Declare Function GetMessage Lib "user32" Alias "GetMessageA" (lpMsg As Msg, ByVal hWnd As Long, ByVal wMsgFilterMin As Long, ByVal wMsgFilterMax As Long) As Long -Public Declare Function DefineDosDevice Lib "kernel32" Alias "DefineDosDeviceA" (ByVal dwFlags As Long, ByVal lpDeviceName As String, ByVal lpTargetPath As String) As Long -Public Declare Function SetVolumeLabel Lib "kernel32" Alias "SetVolumeLabelA" (ByVal lpRootPathName As String, ByVal lpVolumeName As String) As Long -Public Declare Function TextOut Lib "gdi32" Alias "TextOutA" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal lpString As String, ByVal nCount As Long) As Long -Public Declare Function CreateFile Lib "kernel32" Alias "CreateFileA" (ByVal lpFileName As String, ByVal dwDesiredAccess As Long, ByVal dwShareMode As Long, ByVal ZERO As Long, ByVal dwCreationDisposition As Long, ByVal dwFlagsAndAttributes As Long, ByVal hTemplateFile As Long) As Long -Public Declare Function WriteFile Lib "kernel32" (ByVal hFile As Long, lpBuffer As Any, ByVal nNumberOfBytesToWrite As Long, lpNumberOfBytesWritten As Long, ByVal ZERO As Long) As Long -Public Declare Function ReadFile Lib "kernel32" (ByVal hFile As Long, lpBuffer As Any, ByVal nNumberOfBytesToRead As Long, lpNumberOfBytesRead As Long, ByVal ZERO As Long) As Long -Public Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Long) As Long -Public Declare Function mciSendString Lib "winmm.dll" Alias "mciSendStringA" (ByVal lpstrCommand As String, ByVal lpstrReturnString As String, ByVal uReturnLength As Long, ByVal hwndCallback As Long) As Long -Public Declare Function AlphaBlending Lib "msimg32.dll" Alias "AlphaBlend" (ByVal hDCDest As Long, ByVal nXOriginDest As Long, ByVal nYOriginDest As Long, ByVal nWidthDest As Long, ByVal nHeightDest As Long, ByVal hdcSrc As Long, ByVal nXOriginSrc As Long, ByVal nYOriginSrc As Long, ByVal nWidthSrc As Long, ByVal nHeightSrc As Long, ByVal BF As Long) As Long -Public Declare Function ShowWindow Lib "user32" (ByVal hWnd As Long, ByVal nCmdShow As Long) As Long -Public Declare Function GetWindowDC Lib "user32" (ByVal hWnd As Long) As Long -Public Declare Function CreateCompatibleBitmap Lib "gdi32" (ByVal hdc As Long, ByVal nWidth As Long, ByVal nHeight As Long) As Long -Public Declare Function GetDeviceCaps Lib "gdi32" (ByVal hdc As Long, ByVal nIndex As Long) As Long -Public Declare Function GetWindowsDirectory Lib "kernel32" Alias "GetWindowsDirectoryA" (ByVal lpBuffer As String, ByVal nSize As Long) As Long -Public Declare Function GetSysColor Lib "user32" (ByVal nIndex As Long) As Long -Public Declare Function SystemParametersInfo Lib "user32" Alias "SystemParametersInfoA" (ByVal uAction As Long, ByVal uParam As Long, ByRef lpvParam As Any, ByVal fuWinIni As Long) As Long -Public Declare Function GetWindow Lib "user32" (ByVal hWnd As Long, ByVal wCmd As Long) As Long -Public Declare Function EnableWindow Lib "user32" (ByVal hWnd As Long, ByVal fEnable As Long) As Long -Public Declare Function GetEnvironmentVariable Lib "kernel32" Alias "GetEnvironmentVariableA" (ByVal lpName As String, ByVal lpBuffer As String, ByVal nSize As Long) As Long -Public Declare Function GetClassName Lib "user32" Alias "GetClassNameA" (ByVal hWnd As Long, ByVal lpClassName As String, ByVal nMaxCount As Long) As Long -Public Declare Function IsWindowVisible Lib "user32" (ByVal hWnd As Long) As Long -Public Declare Function GetDriveType Lib "kernel32" Alias "GetDriveTypeA" (ByVal nDrive As String) As Long -Public Declare Function FindWindowS Lib "user32" Alias "FindWindowA" (ByVal lpClassName As Long, ByVal lpWindowName As String) As Long -Public Declare Function GetVersionEx Lib "kernel32" Alias "GetVersionExA" (lpVersionInformation As OSVERSIONINFO) As Long -Public Declare Function ExtractIcon Lib "shell32.dll" Alias "ExtractIconA" (ByVal hInst As Long, ByVal lpszExeFileName As String, ByVal nIconIndex As Long) As Long - -Public Declare Function SetLayeredWindowAttributes Lib "user32.dll" (ByVal handle As Long, ByVal param1 As Long, ByVal param2 As Byte, ByVal Param3 As Long) As Long -Public Declare Function RedrawWindow Lib "user32" (ByVal hWnd As Long, ByVal ZERO As Long, ByVal hrgnUpdate As Long, ByVal fuRedraw As Long) As Long - -Public Declare Function GetDIBits Lib "gdi32" (ByVal ahDc As Long, ByVal hBitmap As Long, ByVal nStartScan As Long, ByVal nNumScans As Long, lpBits As Any, lpBI As BITMAPINFO, ByVal wUsage As Long) As Long -Public Declare Function SetDIBits Lib "gdi32" (ByVal hdc As Long, ByVal hBitmap As Long, ByVal nStartScan As Long, ByVal nNumScans As Long, lpBits As Any, lpBI As BITMAPINFO, ByVal wUsage As Long) As Long -Public Declare Function GetPixelRGB Lib "gdi32" Alias "GetPixel" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long) As pRGB -Public Declare Function SetPixelRGB Lib "gdi32" Alias "SetPixelV" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal crColor As pRGB) As Long -Public Declare Function BitBlt32to24C Lib "Grender.DLL" Alias "_Render_BitBlt32to24@32" (ByRef vbDestGSprite As Sprite24, ByVal x As Long, ByVal y As Long, ByVal W As Long, ByVal h As Long, ByRef vbSource As Sprite32, ByVal SrcX As Long, ByVal SrcY As Long) As Long -Public Declare Function BitBlt24to24C Lib "Grender.DLL" Alias "_Render_BitBlt24to24@32" (ByRef vbDestGSprite As Sprite24, ByVal x As Long, ByVal y As Long, ByVal W As Long, ByVal h As Long, ByRef vbSource As Sprite24, ByVal SrcX As Long, ByVal SrcY As Long) As Long -Public Declare Function InvertAlpha32C Lib "Grender.DLL" Alias "_Render_InvertAlpha32@20" (ByRef vbDestGSprite As Sprite32, ByVal x As Long, ByVal y As Long, ByVal W As Long, ByVal h As Long) As Long -Public Declare Function AlphaAdd32C Lib "Grender.DLL" Alias "_Render_AlphaAdd32@24" (ByRef vbDestGSprite As Sprite32, ByVal x As Long, ByVal y As Long, ByVal W As Long, ByVal h As Long, ByVal Add As Long) As Long - -Public Declare Function mUBOUND Lib "Grender.DLL" Alias "_mUBOUND@8" (ByRef ArrayP() As Any, Optional ByVal Dimension As Long = 1) As Long -Public Declare Function mLBOUND Lib "Grender.DLL" Alias "_mLBOUND@8" (ByRef ArrayP() As Any, Optional ByVal Dimension As Long = 1) As Long -Public Declare Function VBArrayPointer Lib "GRAPH.DLL" Alias "_VBArrayPointer@4" (ByRef ArrayP() As Any) As Long -Public Declare Function VBArrayPointerVal Lib "GRAPH.DLL" Alias "_VBArrayPointer@4" (ByVal ArrayP As Long) As Long -Public Declare Function GetVBString Lib "GRAPH.DLL" Alias "_GetVBString@4" (ByRef vbString As String) As Long -Public Declare Function CreateIconIndirect Lib "user32" (piconinfo As ICONINFO) As Long -Public Declare Function GetSystemMetrics Lib "user32" (ByVal nIndex As Long) As Long -Public Declare Sub CopyMemoryC Lib "Grender.DLL" Alias "_CopyMemoryC@12" (ByRef Destination As Any, ByRef Source As Any, ByVal Length As Long) - - -Public Declare Function GetMenu Lib "user32" (ByVal hWnd As Long) As Long -Public Declare Function GetMenuItemID Lib "user32" (ByVal hMenu As Long, ByVal nPos As Long) As Long -Public Declare Function GetSubMenu Lib "user32" (ByVal hMenu As Long, ByVal nPos As Long) As Long -Public Declare Function ModifyMenu Lib "user32" Alias "ModifyMenuA" (ByVal hMenu As Long, ByVal nPosition As Long, ByVal wFlags As Long, ByVal wIDNewItem As Long, ByVal lpString As Any) As Long - -Public Const MF_BITMAP = 4 -Public Const MF_CHECKED = 8 - -Const SM_CXSMICON As Long = 49 -Const SM_CYSMICON As Long = 50 - -Public Declare Function compress Lib "zlib.dll" (dest As Any, destLen As Any, src As Any, ByVal srcLen As Long) As Long -Public Declare Function compress2 Lib "zlib.dll" (dest As Any, destLen As Any, src As Any, ByVal srcLen As Long, ByVal level As Long) As Long -Public Declare Function uncompress Lib "zlib.dll" (dest As Any, destLen As Any, src As Any, ByVal srcLen As Long) As Long - -Public Declare Function UpdateLayeredWindow Lib "user32.dll" (ByVal hWnd As Long, _ -ByVal hdcDst As Long, pptDst As Any, psize As Any, ByVal hdcSrc As Long, pptSrc As Any, ByVal crKey As Long, ByRef pblend As blendFunction, ByVal dwFlags As Long) As Long - - -Const SWP_NOSIZE = &H1 -Const SWP_NOMOVE = &H2 -Public Const SWP_NOOWNERZORDER = &H200 ' Don't do owner Z ordering - - -Public Const SND_RESOURCE = &H40004 ' name is a resource name or atom - - -Enum CZErrors - Z_OK = 0 - Z_STREAM_END = 1 - Z_NEED_DICT = 2 - Z_ERRNO = -1 - Z_STREAM_ERROR = -2 - Z_DATA_ERROR = -3 - Z_MEM_ERROR = -4 - Z_BUF_ERROR = -5 - Z_VERSION_ERROR = -6 -End Enum - -Public Enum CompressionLevels - Z_NO_COMPRESSION = 0 - Z_BEST_SPEED = 1 - 'note that levels 2-8 exist, too - Z_BEST_COMPRESSION = 9 - Z_DEFAULT_COMPRESSION = -1 -End Enum - - -Public Const WS_EX_NOACTIVATE As Long = &H8000000 - -Public Const NORMAL_PRIORITY_CLASS = &H20 -Public Const HIGH_PRIORITY_CLASS = &H80 -Public Const REALTIME_PRIORITY_CLASS = &H100 -Public Const GWL_EXSTYLE = (-20) -'#,##0 -'Public Const Format3 As String = "### ### ### ### ### ### ### ### ### ### ###" - -Public Const RDW_ALLCHILDREN = &H80 -Public Const RDW_ERASE = &H4 -Public Const RDW_ERASENOW = &H200 -Public Const RDW_FRAME = &H400 -Public Const RDW_INTERNALPAINT = &H2 -Public Const RDW_INVALIDATE = &H1 -Public Const RDW_NOCHILDREN = &H40 -Public Const RDW_NOERASE = &H20 -Public Const RDW_NOFRAME = &H800 -Public Const RDW_NOINTERNALPAINT = &H10 -Public Const RDW_UPDATENOW = &H100 -Public Const RDW_VALIDATE = &H8 - -Public Const GW_CHILD = 5 -Public Const GW_HWNDFIRST = 0 -Public Const GW_HWNDLAST = 1 -Public Const GW_HWNDNEXT = 2 -Public Const GW_HWNDPREV = 3 -Public Const GW_MAX = 5 -Public Const GW_OWNER = 4 - -Public Const GENERIC_READ = &H80000000 -Public Const GENERIC_WRITE = &H40000000 -Public Const CREATE_NEW = 1 -Public Const OPEN_EXISTING = 3 - -Public Const FILE_SHARE_READ = &H1 -Public Const FILE_SHARE_WRITE = &H2 - -Public Const FILE_FLAG_BACKUP_SEMANTICS = &H2000000 -Public Const FILE_FLAG_DELETE_ON_CLOSE = &H4000000 -Public Const FILE_FLAG_NO_BUFFERING = &H20000000 -Public Const FILE_FLAG_OVERLAPPED = &H40000000 -Public Const FILE_FLAG_POSIX_SEMANTICS = &H1000000 -Public Const FILE_FLAG_RANDOM_ACCESS = &H10000000 -Public Const FILE_FLAG_SEQUENTIAL_SCAN = &H8000000 -Public Const FILE_FLAG_WRITE_THROUGH = &H80000000 - -Public Const FILE_ATTRIBUTE_ARCHIVE = &H20 -Public Const FILE_ATTRIBUTE_COMPRESSED = &H800 -Public Const FILE_ATTRIBUTE_DIRECTORY = &H10 -Public Const FILE_ATTRIBUTE_HIDDEN = &H2 -Public Const FILE_ATTRIBUTE_NORMAL = &H80 -Public Const FILE_ATTRIBUTE_READONLY = &H1 -Public Const FILE_ATTRIBUTE_SYSTEM = &H4 -Public Const FILE_ATTRIBUTE_TEMPORARY = &H100 - -Const HORZRES = 8 -Const VERTRES = 10 -Const BITSPIXEL = 12 - -Public Const SRCCOPY = &HCC0020 -Const MAX_TOOLTIP As Integer = 256 - -Public Const NOTIFYICON_VERSION = &H3 - - Public Const WM_MOUSEMOVE = &H200 ' Mouse Move - Public Const WM_LBUTTONDOWN = &H201 ' Left Button Down - Public Const WM_LBUTTONUP = &H202 ' Left Button Up - Public Const WM_LBUTTONDBLCLK = &H203 ' Left Button Double Click - Public Const WM_RBUTTONDOWN = &H204 ' Right Button Down - Public Const WM_RBUTTONUP = &H205 ' Right Button Up - Public Const WM_RBUTTONDBLCLK = &H206 ' Right Button Double Click - Public Const WM_USER = &H400 - Public Const WM_BALLOONL = WM_USER + &H5 ' Left Button on Balloon - Public Const WM_BALLOONR = WM_USER + &H4 ' Right Button on Balloon - Public Const WM_USER_SYSTRAY = WM_USER + &H5 - - -Public Enum BalloonMessage - BalloonShow = WM_USER + 2 - BalloonHide = WM_USER + 3 - BalloonTimeout = WM_USER + 4 - balloonUserClick = WM_USER + 5 -End Enum - -Public Enum BalloonIcons - NoIcon = &H0 - Information = &H1 - Exclamation = &H2 - Critical = &H3 - TrayIcon = &H4 - Question = &H7 -End Enum - -Public Enum IconState - Hidden = &H1 - SHAREDICON = &H2 -End Enum - -Public Enum Action ' Actions for dealing with the system Tray - Add = &H0 ' Add a system tray icon - MODIFY = &H1 ' Modify a system tray icon - Delete = &H2 ' Delete a system tray icon - SetFocus = &H3 - SetVersion = &H4 - Version = &H5 -End Enum - - -Public Enum Info_Flags - None = &H0 ' No icon. - Info = &H1 ' An information icon. - warning = &H2 ' A warning icon.0 - Error = &H3 ' An error icon. - Guid = &H5 - ICON_MASK = &HF ' Version 6.0. Reserved. - NOSOOUND = &H10 ' Version 6.0. Do not play the associated sound. Applies only to balloon ToolTips. -End Enum - -Public Enum Icon_Flags ' Flags you can set on the system tray - message = &H1 ' System Messages - Icon = &H2 ' Icon - Tip = &H4 ' Tooltip - State = &H8 - Info = &H10 -End Enum - -Public Const IMAGE_BITMAP As Long = 0 -Public Const IMAGE_ICON As Long = 1 -Public Const IMAGE_CURSOR As Long = 2 - -Public Const DDD_EXACT_MATCH_ON_REMOVE = &H4 -Public Const DDD_RAW_TARGET_PATH = &H1 -Public Const DDD_REMOVE_DEFINITION = &H2 - -Public Const ButtonLightShadow As Long = &H80000016 -Public Const ButtonDarkShadow As Long = &H80000015 -Public Const ButtonShadow As Long = &H80000010 - -Public Const KEY_QUERY_VALUE = &H1 -Public Const KEY_SET_VALUE = &H2 -Public Const KEY_CREATE_SUB_KEY = &H4 -Public Const KEY_ENUMERATE_SUB_KEYS = &H8 -Public Const KEY_NOTIFY = &H10 -Public Const KEY_CREATE_LINK = &H20 -Public Const STANDARD_RIGHTS_ALL = &H1F0000 -Public Const SYNCHRONIZE = &H100000 -Public Const KEY_ALL_ACCESS = ((STANDARD_RIGHTS_ALL Or KEY_QUERY_VALUE Or KEY_SET_VALUE Or KEY_CREATE_SUB_KEY Or KEY_ENUMERATE_SUB_KEYS Or KEY_NOTIFY Or KEY_CREATE_LINK) And (Not SYNCHRONIZE)) - -Public Const DM_BITSPERPEL = &H40000 -Public Const DM_PELSWIDTH = &H80000 -Public Const DM_PELSHEIGHT = &H100000 -Public Const CCHDEVICENAME = 32 -Public Const CCHFORMNAME = 32 - -Type DEVMODE - dmDeviceName As String * CCHDEVICENAME - dmSpecVersion As Integer - dmDriverVersion As Integer - dmSize As Integer - dmDriverExtra As Integer - dmFields As Long - dmOrientation As Integer - dmPaperSize As Integer - dmPaperLength As Integer - dmPaperWidth As Integer - dmScale As Integer - dmCopies As Integer - dmDefaultSource As Integer - dmPrintQuality As Integer - dmColor As Integer - dmDuplex As Integer - dmYResolution As Integer - dmTTOption As Integer - dmCollate As Integer - dmFormName As String * CCHFORMNAME - dmUnusedPadding As Integer - dmBitsPerPel As Integer - dmPelsWidth As Long - dmPelsHeight As Long - dmDisplayFlags As Long - dmDisplayFrequency As Long -End Type - -Public Type Guid - Data1 As Long - Data2 As Integer - Data3 As Integer - Data4(7) As Byte -End Type - -Public Type NOTIFYICONDATA - cbSize As Long - hWnd As Long - uId As Long - uFlags As Long - uCallbackMessage As Long - hIcon As Long - szTip As String * 128 - dwState As Long - dwStateMask As Long - szInfo As String * 256 - uTimeoutAndVersion As Long - szInfoTitle As String * 64 - dwInfoFlags As Long - guidItem As Guid -End Type - -Public Type OSVERSIONINFO - dwOSVersionInfoSize As Long - dwMajorVersion As Long - dwMinorVersion As Long - dwBuildNumber As Long - dwPlatformId As Long - szCSDVersion As String * 128 ' Maintenance string for PSS usage -End Type - -Public nidProgramData As NOTIFYICONDATA -Public nidBalloon As NOTIFYICONDATA - -Public Type SAFEARRAYBOUND - cElements As Long - lLbound As Long -End Type -Public Type SAFEARRAY2D - cDims As Integer - fFeatures As Integer - cbElements As Long - cLocks As Long - pvData As Long - Bounds(0 To 1) As SAFEARRAYBOUND -End Type - -Public Type SHFILEINFO - hIcon As Long - iIcon As Long - dwAttributes As Long - szDisplayName As String * 260 - szTypeName As String * 80 -End Type - -Public Type RECT - Left As Long - Top As Long - Right As Long - Bottom As Long -End Type - -Public Type tPicture - PDC As Long - pBitmap As Long - pBitmapBits As Long - mDC As Long - mBitmap As Long - Width As Long - Height As Long - OldmBitmap As Long - OldpBitmap As Long -End Type - -Public Type blendFunction - BlendOp As Byte - BlendFlags As Byte - SourceConstantAlpha As Byte - AlphaFormat As Byte -End Type - -Public Type pRGB - r As Byte - g As Byte - B As Byte - A As Byte -End Type - -Public Type nRGB - B As Byte - g As Byte - r As Byte -End Type - - -Public Type ICONINFO - fIcon As Long - xHotspot As Long - yHotspot As Long - hBmMask As Long - hBmColor As Long -End Type - -Public Type PictDesc - cbSizeofStruct As Long - picType As Long - hImage As Long - xExt As Long - yExt As Long -End Type - -Public Type ICONDIR - idReserved As Integer - idType As Integer - IDCount As Integer -End Type - -Public Type ICONDIRENTRY - bWidth As Byte - bHeight As Byte - bColorCount As Byte - bReserved As Byte - wPlanes As Integer - wBitCount As Integer - dwBytesInRes As Long - dwImageOffset As Long -End Type - -Public Const SWP_DRAWFRAME = &H20 -Public Const SWP_NOZORDER = &H4 -Public Const SWP_FLAGS = SWP_NOZORDER Or SWP_NOSIZE Or SWP_NOMOVE Or SWP_DRAWFRAME -Public Const WS_THICKFRAME = &H40000 -Public Const WS_FIXED = &H400000 -Public Const WM_SYSCOMMAND = &H112 -Public Const GWL_STYLE = (-16) -Public Const SC_MOVE = &HF012 -Public Const WM_GETTEXTLENGTH = &HE -Public Const WM_GETTEXT = &HD -Public Const WM_SETTEXT = &HC -Public Const WM_KEYDOWN = &H100 -Public Const WM_KEYUP = &H101 - - -Public Const SW_ERASE = &H4 -Public Const SW_HIDE = 0 -Public Const SW_INVALIDATE = &H2 -Public Const SW_MAX = 10 -Public Const SW_MAXIMIZE = 3 -Public Const SW_MINIMIZE = 6 -Public Const SW_NORMAL = 1 -Public Const SW_OTHERUNZOOM = 4 -Public Const SW_OTHERZOOM = 2 -Public Const SW_PARENTCLOSING = 1 -Public Const SW_PARENTOPENING = 3 -Public Const SW_RESTORE = 9 -Public Const SW_SCROLLCHILDREN = &H1 -Public Const SW_SHOW = 5 -Public Const SW_SHOWDEFAULT = 10 -Public Const SW_SHOWMAXIMIZED = 3 -Public Const SW_SHOWMINIMIZED = 2 -Public Const SW_SHOWMINNOACTIVE = 7 -Public Const SW_SHOWNA = 8 -Public Const SW_SHOWNOACTIVATE = 4 -Public Const SW_SHOWNORMAL = 1 - -Public Const HWND_TOP = 0 - -Const DRIVE_REMOVABLE = 2 -Const DRIVE_FIXED = 3 -Const DRIVE_REMOTE = 4 -Const DRIVE_CDROM = 5 -Const DRIVE_RAMDISK = 6 - -Public Type POINTAPI - x As Long - y As Long -End Type - -Public Type PictureBuffer - SPicture() As Long -End Type - -Public Type fString - S As String -End Type - -Public Enum WinTOP - OnTop = -1 - NOTONTOP = -2 -End Enum - -Public Enum WinVisible - isvisible = 0 - isINVISIBLE = 1 -End Enum - - -Public Type BITMAP - bmType As Long - bmWidth As Long - bmHeight As Long - bmWidthBytes As Long - bmPlanes As Integer - bmBitsPixel As Integer - bmBits As Long -End Type - -Public Type RGBQUAD - rgbBlue As Byte - rgbGreen As Byte - rgbRed As Byte - rgbReserved As Byte -End Type - -Public Type BITMAPINFOHEADER '40 bytes - biSize As Long - biWidth As Long - biHeight As Long - biPlanes As Integer - biBitCount As Integer - biCompression As Long - biSizeImage As Long - biXPelsPerMeter As Long - biYPelsPerMeter As Long - biClrUsed As Long - biClrImportant As Long -End Type - -Public Type BITMAPINFO - bmiHeader As BITMAPINFOHEADER - bmiColors As RGBQUAD -End Type - -Public Type Msg - hWnd As Long - message As Long - wParam As Long - lParam As Long - time As Long - pt As POINTAPI -End Type - - -Public Const VK_ADD = &H6B -Public Const VK_ATTN = &HF6 -Public Const VK_BACK = &H8 -Public Const VK_CANCEL = &H3 -Public Const VK_CAPITAL = &H14 -Public Const VK_CLEAR = &HC -Public Const VK_CONTROL = &H11 -Public Const VK_CRSEL = &HF7 -Public Const VK_DECIMAL = &H6E -Public Const VK_DELETE = &H2E -Public Const VK_DIVIDE = &H6F -Public Const VK_DOWN = &H28 -Public Const VK_END = &H23 -Public Const VK_EREOF = &HF9 -Public Const VK_ESCAPE = &H1B -Public Const VK_EXECUTE = &H2B -Public Const VK_EXSEL = &HF8 -Public Const VK_F1 = &H70 -Public Const VK_F10 = &H79 -Public Const VK_F11 = &H7A -Public Const VK_F12 = &H7B -Public Const VK_F13 = &H7C -Public Const VK_F14 = &H7D -Public Const VK_F15 = &H7E -Public Const VK_F16 = &H7F -Public Const VK_F17 = &H80 -Public Const VK_F18 = &H81 -Public Const VK_F19 = &H82 -Public Const VK_F2 = &H71 -Public Const VK_F20 = &H83 -Public Const VK_F21 = &H84 -Public Const VK_F22 = &H85 -Public Const VK_F23 = &H86 -Public Const VK_F24 = &H87 -Public Const VK_F3 = &H72 -Public Const VK_F4 = &H73 -Public Const VK_F5 = &H74 -Public Const VK_F6 = &H75 -Public Const VK_F7 = &H76 -Public Const VK_F8 = &H77 -Public Const VK_F9 = &H78 -Public Const VK_HELP = &H2F -Public Const VK_HOME = &H24 -Public Const VK_INSERT = &H2D -Public Const VK_LBUTTON = &H1 -Public Const VK_LCONTROL = &HA2 -Public Const VK_LEFT = &H25 -Public Const VK_LMENU = &HA4 -Public Const VK_LSHIFT = &HA0 -Public Const VK_MBUTTON = &H4 ' NOT contiguous with L RBUTTON -Public Const VK_MENU = &H12 -Public Const VK_MULTIPLY = &H6A -Public Const VK_NEXT = &H22 -Public Const VK_NONAME = &HFC -Public Const VK_NUMLOCK = &H90 -Public Const VK_NUMPAD0 = &H60 -Public Const VK_NUMPAD1 = &H61 -Public Const VK_NUMPAD2 = &H62 -Public Const VK_NUMPAD3 = &H63 -Public Const VK_NUMPAD4 = &H64 -Public Const VK_NUMPAD5 = &H65 -Public Const VK_NUMPAD6 = &H66 -Public Const VK_NUMPAD7 = &H67 -Public Const VK_NUMPAD8 = &H68 -Public Const VK_NUMPAD9 = &H69 -Public Const VK_OEM_CLEAR = &HFE -Public Const VK_PA1 = &HFD -Public Const VK_PAUSE = &H13 -Public Const VK_PLAY = &HFA -Public Const VK_PRINT = &H2A -Public Const VK_PRIOR = &H21 -Public Const VK_PROCESSKEY = &HE5 -Public Const VK_RBUTTON = &H2 -Public Const VK_RCONTROL = &HA3 -Public Const VK_RETURN = &HD -Public Const VK_RIGHT = &H27 -Public Const VK_RMENU = &HA5 -Public Const VK_RSHIFT = &HA1 -Public Const VK_SCROLL = &H91 -Public Const VK_SELECT = &H29 -Public Const VK_SEPARATOR = &H6C -Public Const VK_SHIFT = &H10 -Public Const VK_SNAPSHOT = &H2C -Public Const VK_SPACE = &H20 -Public Const VK_SUBTRACT = &H6D -Public Const VK_TAB = &H9 -Public Const VK_UP = &H26 -Public Const VK_ZOOM = &HFB - -Public Const CLR_WHITE As Long = 16777215 -Public Const CLR_GREEN As Long = 65280 -Public Const CLR_RED As Long = 255 -Public Const CLR_BLUE As Long = 16711680 -Public Const CLR_YELLOW As Long = 65535 -Public Const CLR_PINK As Long = 16711935 - -Public Const SPI_GETGRADIENTCAPTIONS As Long = &H1008 -Public Const COLOR_ACTIVECAPTION = 2 -Public Const COLOR_GRADIENTACTIVECAPTION As Long = 27 - -'Public Type SAFEARRAYBOUND -' cElements As Long -' lLbound As Long -'End Type -Public Type SAFEARRAY - cDims As Integer - fFeatures As Integer - cbElements As Long - cLocks As Long - pvData As Long - 'Bounds(0 To 0) As SAFEARRAYBOUND -End Type - -Public Type SAFEARRAY1D - cDims As Integer - fFeatures As Integer - cbElements As Long - cLocks As Long - pvData As Long - Bounds(0 To 0) As SAFEARRAYBOUND -End Type - -Public Type BGRT - B As Byte - g As Byte - r As Byte - T As Byte -End Type - -Public Type Sprite32 - Width As Long - Height As Long - bits() As BGRT -End Type - -Public Type Sprite24 - Width As Long - Height As Long - bits() As Byte -End Type - -Public Type IconsHandles - Icon As Sprite32 - handle As Long -End Type - -Public IconHandles() As IconsHandles -Dim RGNM() As Integer, RGNC As Integer, RGN_API() As POINTAPI -Public TTMP As Long, TString1 As String, TString2 As String -Public TFill(21) As Long, BeginTime As Long, TTMP2 As Long, TTMP3 As Long -Dim nfIconData As NOTIFYICONDATA - - -Public Function GetSecondColor() As Long -Dim B As Long -SystemParametersInfo SPI_GETGRADIENTCAPTIONS, 0, B, 0 -If Not B = 0 Then - GetSecondColor = GetSysColor(COLOR_GRADIENTACTIVECAPTION) -Else - GetSecondColor = GetSysColor(COLOR_ACTIVECAPTION) -End If -End Function - -Public Function ArrayToString(S As String, Arr() As Byte) As Long -Dim sptr As Long, IC As Long - -IC = UBound(Arr) -S = String$(IC, " ") - -CopyMemory ByVal S, Arr(1), IC -ArrayToString = IC -End Function - -Public Function StringToArray(S As String, Arr() As Byte) As Long -Dim sptr As Long, IC As Long - -IC = Len(S) -ReDim Arr(1 To IC) As Byte - -CopyMemory Arr(1), ByVal S, IC -StringToArray = IC -End Function - -Public Function StringToArrayFast(S As String, Arr() As Byte) As Long -Dim sptr As Long, IC As Long - -IC = Len(S) - -CopyMemory Arr(1), ByVal S, IC -StringToArrayFast = IC -End Function - -Public Function TimeRange(STime As String, ETime As String, cTime As String) As Byte -Dim H1 As Double, H2 As Double, HC As Double - -H1 = Hour(STime) + Minute(STime) / 100 -H2 = Hour(ETime) + Minute(ETime) / 100 -HC = Hour(cTime) + Minute(cTime) / 100 - -TimeRange = CheckTime(H1, H2, HC) -End Function - -Public Function SetMINProcess(hWnd As Long) -Dim x As Long, y As Long - -GetWindowThreadProcessId hWnd, y -x = OpenProcess(&H1F0FFF, 1, y) -SetPriorityClass x, &H40 -SetThreadPriority y, 2 -CloseHandle x -End Function - -Public Function SetNORProcess(hWnd As Long) -Dim x As Long, y As Long - -GetWindowThreadProcessId hWnd, y -x = OpenProcess(&H1F0FFF, 1, y) -SetPriorityClass x, NORMAL_PRIORITY_CLASS -SetThreadPriority y, 2 -CloseHandle x -End Function - -Public Function SetMAXProcess(hWnd As Long) -Dim x As Long, y As Long - -GetWindowThreadProcessId hWnd, y -x = OpenProcess(&H1F0FFF, 1, y) -SetPriorityClass x, HIGH_PRIORITY_CLASS -SetThreadPriority y, 2 -CloseHandle x -End Function - -Public Function SetRealTimeProcess(hWnd As Long) -Dim x As Long, y As Long - -GetWindowThreadProcessId hWnd, y -x = OpenProcess(&H1F0FFF, 1, y) -SetPriorityClass x, REALTIME_PRIORITY_CLASS -SetThreadPriority y, 15 -CloseHandle x -End Function - -Public Function RunWEB(Site As String, Optional Param As String) -Call ShellExecute(0, "open", Site, Param, "", 1) -End Function - -Public Function wStr(Value As Variant) As String -wStr = Format$(Value) -End Function - -Public Function MStr(Value As Variant) As String -MStr = Mid(Str(Value), 2) -End Function - -Public Sub CheckNumber(Number, Min, Max) -If Number < Min Then Number = Min -If Number > Max Then Number = Max -End Sub - -Public Sub CheckByte(Number As Integer) -If Number < 0 Then Number = 0 -If Number > 255 Then Number = 255 -End Sub - -Public Sub CheckNumberFAST(Number As Integer, Min As Integer, Max As Integer) -If Number < Min Then Number = Min -If Number > Max Then Number = Max -End Sub - -Public Function WriteToFile(File As String, Text As String) -Open File For Output As #1 - Print #1, Text -Close #1 -End Function - -Public Function WindowPOS(win As Form, Pos As WinTOP) -SetWindowPos win.hWnd, Pos, win.Left / Screen.TwipsPerPixelX, win.Top / Screen.TwipsPerPixelY, win.Width / Screen.TwipsPerPixelX, win.Height / Screen.TwipsPerPixelY, &H10 -End Function - -Public Function StartFileEx(File As String, Parameters As String, hWnd As Long) As Long -StartFileEx = ShellExecute(hWnd, "open", File, Parameters, GetPathOnlyIN(File), 1) -End Function - -Public Function StartFile(File As String, Optional Parameters As String) As Long -StartFile = ShellExecute(0, "open", File, Parameters, GetPathOnlyIN(File), 1) -End Function - -Public Function GetFileNameIN(FilePath As String) -Dim CN, A, B -CN = 1 -ret: - A = InStr(CN, FilePath, "\") - If A = 0 Then - GetFileNameIN = Mid(FilePath, B - -1): Exit Function - Else - CN = A - -1: B = InStr(CN, FilePath, "\") - If B = 0 Then - GetFileNameIN = Mid(FilePath, A - -1): Exit Function - Else - CN = B - -1: GoTo ret - End If - End If -End Function - -Public Function GetPathOnlyIN(FilePath As String) -Dim A As Long - -A = InStrRev(FilePath, "\") -If A > 1 Then GetPathOnlyIN = Mid$(FilePath, 1, A) -End Function - -Public Function ToINVISIBLEProcess(ProcessID As Long, Pos As WinVisible) -On Error Resume Next - Call RegisterServiceProcess(ProcessID, Pos) -End Function - -Public Function ToINVISIBLE(Pos As WinVisible) -On Error Resume Next - Call RegisterServiceProcess(GetCurrentProcessId, Pos) -End Function - -Public Function RegWrite(KeyName As String, Data) -SaveSetting App.EXEName, "Setting", KeyName, Data -End Function - -Public Function RegRead(KeyName As String) -RegRead = GetSetting(App.EXEName, "Setting", KeyName, 0) -End Function - -Public Sub VGrad(PB As PictureBox, StartColor, EndColor, x, y, h, W) -Dim R1, G1, B1, R2, G2, b2, clr, CR, CG, cb, PA As POINTAPI -clr = EndColor -R2 = clr Mod 256 -G2 = (clr \ 256) Mod 256 -b2 = clr \ 256 \ 256 -CheckNumber R2, 0, 255: CheckNumber G2, 0, 255: CheckNumber b2, 0, 255 -clr = StartColor -R1 = clr Mod 256 -G1 = (clr \ 256) Mod 256 -B1 = clr \ 256 \ 256 -CheckNumber R1, 0, 255: CheckNumber G1, 0, 255: CheckNumber B1, 0, 255 -CR = (R2 - R1) / h: CG = (G2 - G1) / h: cb = (b2 - B1) / h -For i = y To y - -h - PB.Line (x, i)-(x - -W, i), RGB(R1, G1, B1) - R1 = R1 - -CR - G1 = G1 - -CG - B1 = B1 - -cb - DoEvents -Next i -End Sub - -Public Sub VGradAPI(PB As PictureBox, StartColor, EndColor, x, y, h, W) -Dim R1 As Integer, G1 As Integer, B1 As Integer, R2 As Integer, G2 As Integer -Dim b2 As Integer, clr As Long, CR As Integer, CG As Integer, cb As Integer, PA As POINTAPI -clr = EndColor -R2 = clr Mod 256 -G2 = (clr \ 256) Mod 256 -b2 = clr \ 256 \ 256 -CheckNumber R2, 0, 255: CheckNumber G2, 0, 255: CheckNumber b2, 0, 255 -clr = StartColor -R1 = clr Mod 256 -G1 = (clr \ 256) Mod 256 -B1 = clr \ 256 \ 256 -CheckNumber R1, 0, 255: CheckNumber G1, 0, 255: CheckNumber B1, 0, 255 -CR = (R2 - R1) / h: CG = (G2 - G1) / h: cb = (b2 - B1) / h -For i = y To y + h - PB.ForeColor = RGB(R1, G1, B1) - MoveToEx PB.hdc, x, i, PA - LineTo PB.hdc, x + W, i - R1 = R1 + CR - G1 = G1 + CG - B1 = B1 + cb - DoEvents -Next i -End Sub - -Public Sub HGradAPI(PB As PictureBox, StartColor As Long, EndColor As Long, x As Long, y As Long, h As Long, W As Long) -On Error Resume Next -Dim R1 As Single, G1 As Single, B1 As Single -Dim R2 As Integer, G2 As Integer, b2 As Integer -Dim clr As Long, CR As Single, CG As Single, cb As Single, PA As POINTAPI -clr = EndColor -R2 = clr Mod 256 -G2 = (clr \ 256) Mod 256 -b2 = clr \ 256 \ 256 -CheckNumber R2, 0, 255: CheckNumber G2, 0, 255: CheckNumber b2, 0, 255 -clr = StartColor -R1 = clr Mod 256 -G1 = (clr \ 256) Mod 256 -B1 = clr \ 256 \ 256 -CheckNumber R1, 0, 255: CheckNumber G1, 0, 255: CheckNumber B1, 0, 255 -CR = (R2 - R1) / W: CG = (G2 - G1) / W: cb = (b2 - B1) / W -For i = x To x + W - PB.ForeColor = RGB(R1, G1, B1) - MoveToEx PB.hdc, i, y, PA - LineTo PB.hdc, i, y + h - R1 = R1 + CR - G1 = G1 + CG - B1 = B1 + cb - 'DoEvents -Next i -End Sub - -Public Function SFix(Number) -If Number < Fix(Number) - -0.5 Then SFix = Fix(Number) Else SFix = Fix(Number) - -1 -End Function - -Public Function SFixByte(Number As Single) As Byte -If Number < Fix(Number) - -0.5 Then SFixByte = Fix(Number) Else SFixByte = Fix(Number) - -1 -End Function - -Public Function SFixLong(Number As Single) As Long -If Number < Fix(Number) - -0.5 Then SFixLong = Fix(Number) Else SFixLong = Fix(Number) - -1 -End Function - -Public Function ProgBeOS(PB As PictureBox, Max, Min, Value, Optional DoNotRefresh As Byte, Optional DoNotCls As Byte, Optional bOrder As Byte) -Dim L As Long, LL As Long, LD As Long, W As Long -L = RGB(18, 155, 240) -If Not PB.ForeColor = L Then PB.ForeColor = L -W = ProgB(PB, Max, Min, Value, 1, DoNotCls) - -LL = RGB(38, 180, 255) -LD = RGB(0, 100, 150) - -If bOrder = 0 Then - If W = 0 Then GoTo NEX - PB.Line (0, 0)-(W, 0), LL - PB.Line (0, 0)-(0, PB.ScaleHeight - 1), LL - PB.Line (0, PB.ScaleHeight - 1)-(W, PB.ScaleHeight - 1), LD - PB.Line (W, 0)-(W, PB.ScaleHeight), LD -Else - PB.Line (0, 0)-(PB.ScaleWidth - 1, 0), &H80000010 - PB.Line (0, 0)-(0, PB.ScaleHeight - 1), &H80000010 - PB.Line (0, PB.ScaleHeight - 1)-(PB.ScaleWidth - 1, PB.ScaleHeight - 1), &H80000016 - PB.Line (PB.ScaleWidth - 1, 0)-(PB.ScaleWidth - 1, PB.ScaleHeight), &H80000016 - - If W = 0 Then GoTo NEX - PB.Line (1, 1)-(W - 1, 1), LL - PB.Line (1, 1)-(1, PB.ScaleHeight - 2), LL - PB.Line (1, PB.ScaleHeight - 2)-(W - 1, PB.ScaleHeight - 2), LD - PB.Line (W, 1)-(W, PB.ScaleHeight - 1), LD -End If - -NEX: -If DoNotRefresh = 0 Then PB.Refresh -End Function - -Public Function ProgB2(PB As PictureBox, Max, Min, Value, Optional DoNotRefresh As Byte, Optional DoNotCls As Byte, Optional LineColor As Long = CLR_WHITE) -ProgB PB, Max, Min, Value, 1, DoNotCls -PB.Line (0, 0)-(PB.ScaleWidth - 1, PB.ScaleHeight - 1), LineColor, B -If DoNotRefresh = 0 Then PB.Refresh -End Function - -Public Function ProgB(PB As PictureBox, Max, Min, Value, Optional DoNotRefresh As Byte, Optional DoNotCls As Byte) -On Error Resume Next -Dim RealMax As Long, Val1 As Double, RealValue As Double -PB.ScaleMode = 3 -If DoNotCls = 0 Then PErase PB 'PB.Cls -RealMax = Max - Min -If RealMax = PB.ScaleWidth Then - Val1 = 1 -Else - Val1 = PB.ScaleWidth / RealMax -End If -RealValue = Val1 * (Value - Min) -If Not Value = Min Then PB.Line (0, 0)-(RealValue, PB.ScaleHeight), , BF -If DoNotRefresh = 0 Then PB.Refresh -ProgB = RealValue -End Function - -Public Function ProgBitmap(PB As PictureBox, Max, Min, Value, SrcDC As Long, Optional DoNotRefresh As Byte, Optional DoNotCls As Byte) -On Error Resume Next -Dim RealMax As Long, Val1 As Double, RealValue As Double -PB.ScaleMode = 3 -If DoNotCls = 0 Then PErase PB 'PB.Cls -RealMax = Max - Min -If RealMax = PB.ScaleWidth Then - Val1 = 1 -Else - Val1 = PB.ScaleWidth / RealMax -End If -RealValue = Val1 * (Value - Min) -If Not Value = Min Then BitBlt PB.hdc, 0, 0, RealValue, PB.ScaleHeight, SrcDC, 0, 0, vbSrcCopy -If DoNotRefresh = 0 Then PB.Refresh -End Function - -Public Sub ProgBNew(PB As PictureBox, Max, Min, Value, Optional Width As Long = 0) -On Error Resume Next -Dim RealMax As Long, Val1 As Double, RealValue As Double, PBSW As Long -PB.ScaleMode = 3 -PB.Cls -RealMax = Max - Min -If Width = 0 Then Width = PB.ScaleHeight -PBSW = PB.ScaleWidth - Width -If RealMax = PBSW Then - Val1 = 1 -Else - Val1 = PBSW / RealMax -End If -RealValue = Val1 * (Value - Min) -If Not Value = Min Then PB.Line (RealValue, 0)-(RealValue + Width, PB.ScaleHeight), , BF -PB.Refresh -End Sub - -Public Sub ProgBnNew(PB As PictureBox, Max, Min, Value, Optional Width As Long = 0) -On Error Resume Next -Dim RealMax As Long, Val1 As Double, RealValue As Double, PBSW As Long -PB.Cls -RealMax = Max - Min -If Width = 0 Then Width = PB.ScaleHeight -PBSW = PB.ScaleWidth - Width -If RealMax = PBSW Then - Val1 = 1 -Else - Val1 = PBSW / RealMax -End If -RealValue = Val1 * (Value - Min) -If Not Value = Min Then PB.Line (RealValue, 0)-(RealValue + Width, PB.ScaleHeight), , BF -End Sub - -Public Function ProgBn(PB As PictureBox, Max, Min, Value) -On Error Resume Next -Dim RealMax, Val1, RealValue -RealMax = Max - Min -If RealMax = PB.ScaleWidth Then - Val1 = 1 -Else - Val1 = PB.ScaleWidth / RealMax -End If -RealValue = Val1 * Value -If Not Value = Min Then PB.Line (0, 0)-(RealValue, PB.ScaleHeight), , BF -End Function - -Public Function ProgBU(PB As PictureBox, Max, Min, Value) -Dim RealMax, Val1, RealValue -PB.ScaleMode = 3 -PB.Cls -RealMax = Max - Min -If RealMax = PB.ScaleHeight Then - Val1 = 1 -Else - Val1 = PB.ScaleHeight / RealMax -End If -RealValue = Val1 * Value -If Not Value = Min Then PB.Line (0, PB.ScaleHeight - RealValue)-(PB.ScaleWidth, PB.ScaleHeight), , BF -End Function - -Public Sub GetRGB(Color, r, g, B) -r = Color Mod 256 -g = (Color \ 256) Mod 256 -B = Color \ 256 \ 256 -If r < 0 Then - r = 0 -Else - If r > 255 Then r = 255 -End If -If g < 0 Then - g = 0 -Else - If g > 255 Then g = 255 -End If -If B < 0 Then - B = 0 -Else - If B > 255 Then B = 255 -End If -End Sub - -Public Sub GetRGBFast(Color As Long, r As Integer, g As Integer, B As Integer) -r = Color Mod 256 -g = (Color \ 256) Mod 256 -B = Color \ 256 \ 256 -If r < 0 Then - r = 0 -Else - If r > 255 Then r = 255 -End If -If g < 0 Then - g = 0 -Else - If g > 255 Then g = 255 -End If -If B < 0 Then - B = 0 -Else - If B > 255 Then B = 255 -End If -End Sub - -Public Function GetOtherColor(Color As Long) As Long -Dim r, g, B -r = Color Mod 256 -g = (Color \ 256) Mod 256 -B = Color \ 256 \ 256 -If r = 255 Then r = 0 Else r = 255 -If g = 255 Then g = 0 Else g = 255 -If B = 255 Then B = 0 Else B = 255 -GetOtherColor = RGB(r, g, B) -End Function - -Public Function GetPercent(Min, Max, Value) -Dim A, RealMax -If Value = 0 Then GetPercent = 0: Exit Function -RealMax = Max - Min -A = RealMax / 100 -If A > 0 Then GetPercent = Value / A -End Function - -Public Function GetPercentFast(Max As Integer, Value As Integer) As Integer -Dim A As Double, RealMax As Integer -If (Value = 0) Or (Max = 0) Then GetPercentFast = 0: Exit Function -A = 100 / Max -If A = 0 Then GetPercentFast = 0: Exit Function -GetPercentFast = CInt(CDbl(Value) * A) -End Function - -Public Function GetPercentFastR(Max As Integer, Value As Integer) As Integer -Dim A As Double, RealMax As Integer -If (Value = 0) Or (Max = 0) Then GetPercentFastR = 0: Exit Function -A = 100 / Max -If A = 0 Then GetPercentFastR = 0: Exit Function -GetPercentFastR = CInt(CDbl(Value) / A) -End Function - -Public Function GetPercentLong(Max As Long, Value As Long) As Long -Dim A As Single, RealMax As Long -If Value = 0 Then GetPercentLong = 0: Exit Function -A = 100 / Max -If A = 0 Then GetPercentLong = 0: Exit Function -GetPercentLong = CLng(CSng(Value) / A) -End Function - -Public Function ToTime(Value) As String -On Error Resume Next -Dim A As Long, B As Byte, M As String, S As String -If Value = 0 Then ToTime = "00:00": Exit Function -A = Value \ 60 -B = Value - A * 60 -M = Format$(A) -S = Format$(B) -If Len(M) = 1 Then M = "0" + M -If Len(S) = 1 Then S = "0" + S -ToTime = M + ":" + S -End Function - -Public Function ToTimeH(Value) As String -Dim A As Long, B As Long, c As Long, M As String, S As String, h As String -If Value = 0 Then ToTimeH = "0:00:00": Exit Function -A = Value \ 60 -B = Value - A * 60 -c = A \ 60 -A = A Mod 60 -M = Format$(A) -S = Format$(B) -h = Format$(c) -If Len(M) = 1 Then M = "0" + M -If Len(S) = 1 Then S = "0" + S -ToTimeH = h + ":" + M + ":" + S -End Function - -Public Sub PaintFromBuffer(Pi As PictureBox, Buff As PictureBuffer, x, y) -Dim h As Long, W As Long, i As Long, j As Long -W = UBound(Buff.SPicture, 1) -h = UBound(Buff.SPicture, 2) -For i = 0 To W - For j = 0 To h - If Not Buff.SPicture(i, j) = -1 Then Pi.PSet (x + i, y + j), Buff.SPicture(i, j) - Next j -Next i -End Sub - -Public Sub PaintToBuffer(Pi As PictureBox, Buff As PictureBuffer, x, y, X2, Y2, Col(), ColCount) -Dim i As Long, j As Long, k As Long, TCol As Long, RW As Long, rH As Long -RW = X2 - x: rH = Y2 - y -For i = 0 To RW - For j = 0 To rH - TCol = Pi.Point(x + i, y + j) - For k = 1 To ColCount - If TCol = Col(i) Then Buff.SPicture(i, j) = -1: GoTo NEX - Next k - Buff.SPicture(i, j) = TCol -NEX: - Next j -Next i -End Sub - -Public Sub SetCoolPBox(Pi As Control) -Dim lStyle As Long, lS As Long -lStyle = GetWindowLong(Pi.hWnd, GWL_STYLE) -lStyle = lStyle Or WS_THICKFRAME -SetWindowLong Pi.hWnd, GWL_STYLE, lStyle -If Pi.Visible = True Then Pi.Visible = False: DoEvents: Pi.Visible = True -End Sub - -Public Sub SetCoolPBox3(Pi As Control) -Dim lStyle As Long, lS As Long -lStyle = GetWindowLong(Pi.hWnd, GWL_STYLE) -lStyle = lStyle Or WS_FIXED -SetWindowLong Pi.hWnd, GWL_STYLE, lStyle -If Pi.Visible = True Then Pi.Visible = False: DoEvents: Pi.Visible = True -End Sub - -Public Sub SetCoolPBox2(Pi As PictureBox, MM As Form) -Dim lStyle As Long, lS As Long -lStyle = GetWindowLong(Pi.hWnd, GWL_STYLE) -lStyle = lStyle Or WS_THICKFRAME -SetWindowLong Pi.hWnd, GWL_STYLE, lStyle -SetWindowPos Pi.hWnd, MM.hWnd, 0, 0, 0, 0, SWP_FLAGS -End Sub - -Public Sub FileAss(ByVal sAppName As String, ByVal sExe As String, ByVal sExt As String, Optional ByVal sIcon As String) -Dim lRegKey As Long -If Not Mid$(sExt, 1, 1) = "." Then sExt = "." + sExt -Call RegCreateKey(HKEY_CLASSES_ROOT, sExt, lRegKey) -Call RegSetValueEx(lRegKey, "", 0&, 1, ByVal sAppName, Len(sAppName)) -Call RegCloseKey(lRegKey) -Call RegCreateKey(HKEY_CLASSES_ROOT, sAppName & "\Shell\Open\Command", lRegKey) -Call RegSetValueEx(lRegKey, "", 0&, 1, ByVal sExe, Len(sExe)) -Call RegCloseKey(lRegKey) -If Len(sIcon) Then - Call RegCreateKey(HKEY_CLASSES_ROOT, sAppName & "\DefaultIcon", lRegKey) - Call RegSetValueEx(lRegKey, "", 0&, 1, ByVal sIcon, Len(sIcon)) - Call RegCloseKey(lRegKey) -End If -End Sub - -Public Sub AddToContextMenu(ByVal sActionName As String, ByVal sMenuText As String, ByVal sExe As String) -Dim lRegKey As Long -Call RegCreateKey(HKEY_CLASSES_ROOT, "*\Shell\" & sActionName, lRegKey) -Call RegSetValueEx(lRegKey, "", 0&, 1, ByVal sMenuText, Len(sMenuText)) -Call RegCloseKey(lRegKey) - -Call RegCreateKey(HKEY_CLASSES_ROOT, "*\Shell\" & sActionName & "\Command", lRegKey) -Call RegSetValueEx(lRegKey, "", 0&, 1, ByVal sExe, Len(sExe)) -Call RegCloseKey(lRegKey) -End Sub - -Public Sub AddToContextMenuEx(ByVal Ext As String, ByVal sActionName As String, ByVal sMenuText As String, ByVal AppName As String, ByVal sExe As String) -Dim lRegKey As Long, S As String, sLen As Long - -If Not Mid$(Ext, 1, 1) = "." Then Ext = "." & Ext - -S = Space(255) -sLen = 255 -Call RegOpenKeyEx(HKEY_CLASSES_ROOT, Ext, 0, KEY_ALL_ACCESS, lRegKey) -Call RegQueryValueEx(lRegKey, "", ByVal 0, 1, ByVal S, sLen) -If sLen > 1 Then - S = Mid$(S, 1, sLen - 1) -Else - Call RegSetValueEx(lRegKey, "", 0&, 1, ByVal AppName, AppName) - S = AppName -End If -Call RegCloseKey(lRegKey) - - -'Call RegCreateKey(HKEY_CLASSES_ROOT, S & "\Shell", lRegKey) -'Call RegSetValueEx(lRegKey, "", 0&, 1, ByVal sMenuText, Len(sMenuText)) -'Call RegCloseKey(lRegKey) - -Call RegCreateKey(HKEY_CLASSES_ROOT, S & "\Shell\" & sActionName, lRegKey) -Call RegSetValueEx(lRegKey, "", 0&, 1, ByVal sMenuText, Len(sMenuText)) -Call RegCloseKey(lRegKey) - -Call RegCreateKey(HKEY_CLASSES_ROOT, S & "\Shell\" & sActionName & "\Command", lRegKey) -Call RegSetValueEx(lRegKey, "", 0&, 1, ByVal sExe, Len(sExe)) -Call RegCloseKey(lRegKey) -End Sub - -Public Function AppFullPath() As String -AppFullPath = DirFilterIN(App.Path) + "\" + App.EXEName + ".exe" -End Function - -Public Function WrtiteBufferToFile(Buff As PictureBuffer, sFile As String) -Dim h As Long, W As Long, i As Long, j As Long -W = UBound(Buff.SPicture, 1) -h = UBound(Buff.SPicture, 2) -Open sFile For Binary As #1 - Put #1, , W - Put #1, , h - Put #1, , Buff.SPicture() -Close #1 -End Function - -Public Function ReadBufferFromFile(Buff As PictureBuffer, sFile As String) -Dim h As Long, W As Long, i As Long, j As Long -Open sFile For Binary As #1 - Get #1, , W - Get #1, , h - ReDim Buff.SPicture(0 To W, 0 To h) As Long - Get #1, , Buff.SPicture() -Close #1 -End Function - -Public Function SFormat(Text As String, FT As String) As String -Dim A As String, B As String, c As Long, i As Long, d As Integer, e As Integer, f As String, g As Byte, k As String -c = Len(Text) -d = Len(FT) -e = 1: g = 0 -For i = 1 To d - k = Mid(FT, i, 1) + k -Next i -For i = 1 To c - If g = 1 Then g = 0: i = i - 1 - A = Mid(Text, c - -1 - i, 1) - f = Mid(k, e, 1) - If f = "#" Then - B = A + B - Else - If i = 1 Then g = 1 Else B = f + B: i = i - 1 - End If - e = e - -1 - If e > d Then e = e - d -Next i -SFormat = B -End Function - -Public Function BINT(ByVal BOOL As Boolean) -If BOOL = False Then BINT = 0 Else BINT = 1 -End Function - -Public Sub TilePictureEx(Orig As PictureBox, Target As PictureBox) -Dim H1 As Long, W1 As Long, WW As Long, HH As Long, DC As Long, DC2 As Long -H1 = 0: W1 = 0 -Orig.ScaleMode = 3: Target.ScaleMode = 3 -DC = Orig.hdc: DC2 = Target.hdc -HH = Target.ScaleHeight: WW = Target.ScaleWidth -Do While H1 < HH - Do While W1 < WW - BitBlt DC2, W1, H1, WW, HH, DC, 0, 0, SRCCOPY - W1 = W1 - -Orig.ScaleWidth - Loop - W1 = 0 - H1 = H1 - -Orig.ScaleHeight -Loop -Orig.ScaleMode = 1: Target.ScaleMode = 1 -End Sub - -Public Sub TilePicture3(Orig As PictureBox, Target As Object) -Dim H1 As Long, W1 As Long, WW As Long, HH As Long, DC As Long, DC2 As Long -H1 = 0: W1 = 0 -DC = Orig.hdc: DC2 = Target.hdc -HH = Target.ScaleHeight: WW = Target.ScaleWidth -Do While H1 < HH - Do While W1 < WW - BitBlt DC2, W1, H1, WW, HH, DC, 0, 0, SRCCOPY - W1 = W1 - -Orig.ScaleWidth - Loop - W1 = 0 - H1 = H1 - -Orig.ScaleHeight -Loop -End Sub - -Public Sub TilePicture3OffsetY(Orig As PictureBox, Target As PictureBox, OffsetY As Long) -On Error Resume Next -Dim H1 As Long, W1 As Long, WW As Long, HH As Long, DC As Long, DC2 As Long -Dim H2 As Long, W2 As Long -H1 = 0: W1 = 0 -DC = Orig.hdc: DC2 = Target.hdc -HH = Target.ScaleHeight: WW = Target.ScaleWidth -H2 = Orig.ScaleHeight: W2 = Orig.ScaleWidth -H1 = -(OffsetY Mod H2) -Do While H1 < HH - Do While W1 < WW - BitBlt DC2, W1, H1, WW, HH, DC, 0, 0, SRCCOPY - W1 = W1 + W2 - Loop - W1 = 0 - H1 = H1 + H2 -Loop -End Sub - -Public Function TilePicture3Ex(dest As PictureBox, src As PictureBox, Optional ByVal OffsetX As Long, Optional ByVal OffsetY As Long, Optional SrcX As Long, Optional SrcY As Long, Optional ByVal SrcW As Long = -1, Optional ByVal SrcH As Long = -1) As Long -Dim i As Long, IC As Long, j As Long, JC As Long, OffX As Long, OffY As Long, OffW As Long, OffH As Long -Dim SW1 As Long, SH1 As Long - -If SrcW = -1 Then SrcW = dest.ScaleWidth -If SrcH = -1 Then SrcH = dest.ScaleHeight - -IC = SrcX + SrcW -JC = SrcY + SrcH - -OffsetX = ((OffsetX Mod (src.ScaleWidth)) - (src.ScaleWidth - 1)) Mod (src.ScaleWidth) -OffsetY = ((OffsetY Mod (src.ScaleHeight)) - (src.ScaleHeight - 1)) Mod (src.ScaleHeight) - -SW1 = (src.ScaleWidth) -SH1 = (src.ScaleHeight) - -For i = OffsetX To IC Step SW1 - If Not i + (src.ScaleWidth - 1) < SrcX Then - For j = OffsetY To JC Step SH1 - If Not j + SH1 < SrcY Then - OffX = SrcX - i: If OffX < 0 Then OffX = 0 - OffY = SrcY - j: If OffY < 0 Then OffY = 0 - OffW = SW1: If i + OffW > IC Then OffW = IC - (i + OffX) - OffH = SH1: If j + OffH > JC Then OffH = JC - (j + OffY) - 'GRender.Draw24To24 Dest, Src, GRENDER_DRAWNORMAL, i + OffX, j + OffY, OffW, OffH, OffX, OffY - BitBlt dest.hdc, i + OffX, j + OffY, OffW, OffH, src.hdc, OffX, OffY, vbSrcCopy - End If - Next - End If -Next -End Function - -Public Sub TilePictureForm(Orig As PictureBox, Target As Form) -Dim H1 As Long, W1 As Long, WW As Long, HH As Long, DC As Long, DC2 As Long -H1 = 0: W1 = 0 -DC = Orig.hdc: DC2 = Target.hdc -HH = Target.ScaleHeight: WW = Target.ScaleWidth -Do While H1 < HH - Do While W1 < WW - BitBlt DC2, W1, H1, WW, HH, DC, 0, 0, SRCCOPY - W1 = W1 - -Orig.ScaleWidth - Loop - W1 = 0 - H1 = H1 - -Orig.ScaleHeight -Loop -End Sub - -Public Function SysDir() As String -Dim h As String, IND As Long -h = String(1024, " ") -GetSystemDirectory h, Len(h) -IND = InStr(1, h, Chr(0)) -SysDir = Mid$(h, 1, IND - 1) -End Function - -Public Function WinDir() As String -Dim h As String, IND As Long -h = String(1024, " ") -GetWindowsDirectory h, Len(h) -IND = InStr(1, h, Chr(0)) -WinDir = Mid$(h, 1, IND - 1) -End Function - -Public Sub TextToByte(Text As String, bytes() As Byte, Count As Long) -Dim A As Long, B As String, i As Long -A = Len(Text) -Count = A -ReDim bytes(1 To A) As Byte -For i = 1 To A - B = Mid$(Text, i, 1) - bytes(i) = Asc(B) -Next i -End Sub - -Public Function ProgB3D(PB As PictureBox, Max, Min, Value, Dark As Long, Light As Long, LaB As Label) -Static QAQ -Dim RealMax, Val1, RealValue, A, B, KKL -PB.ScaleMode = 3 -RealMax = Max - Min -If RealMax = PB.ScaleWidth Then - Val1 = 1 -Else - Val1 = PB.ScaleWidth / RealMax -End If -RealValue = Val1 * Value -If QAQ = RealValue Then GoTo TRE -If QAQ > RealValue Then PB.Cls -QAQ = RealValue -A = RealMax / 100 -B = Value / A -B = Fix(B) -If B > 100 Then B = 100 -LaB.Caption = Format(B) & "%" -'lab.Left = (RealValue / 2) - lab.Width / 2 -PB.Line (0, 0)-(RealValue - 1, PB.ScaleHeight), , BF -PB.Line (0, 0)-(RealValue - 1, PB.ScaleHeight), Light, B -PB.Line (RealValue - 1, 0)-(RealValue - 1, PB.ScaleHeight), Dark -PB.Line (0, PB.ScaleHeight - 1)-(RealValue - 1, PB.ScaleHeight - 1), Dark -TRE: -PB.Refresh -End Function - -Public Function CheckTime(T1, T2, TM) As Byte -'Dim RT1 As Integer, RT2 As Integer, RTM As Integer -If T1 > T2 Then - If TM >= T2 And TM < T1 Then CheckTime = 0: Exit Function Else CheckTime = 1: Exit Function -Else - If TM < T2 And TM >= T1 Then CheckTime = 1: Exit Function Else CheckTime = 0: Exit Function -End If -End Function - -Public Function PlayWAV(FileName As String) -Call sndPlaySound(FileName, 0) -End Function - -Public Function PlayWAVAsync(FileName As String) -Call sndPlaySound(FileName, &H1 Or SND_NOSTOP) -End Function - -Public Function PlayWAVAsyncNoBlam(FileName As String) -Call sndPlaySound(FileName, &H1 Or &H2) -End Function - -Public Function PlayWAVNoSTOP(FileName As String) -Call sndPlaySound(FileName, &H1 Or &H10) -End Function - -Public Function PlayWAVNoSTOPNoBlam(FileName As String) -PlayWAVNoSTOPNoBlam = sndPlaySound(FileName, &H1 Or &H10 Or &H2) -End Function - -Public Function IsNowPlaying() As Boolean -IsNowPlaying = sndPlaySound("", &H1 Or &H10 Or &H2) -End Function - -Public Function PlayWAVNoSTOPEx(FileName As String) As Long -PlayWAVNoSTOPEx = sndPlaySound(FileName, &H1 Or &H10) -End Function - -Public Function PlayWAVLoop(FileName As String) -Call sndPlaySound(FileName, &H1 Or &H8) -End Function - -Public Function PlayWAVLoopNoBlam(FileName As String) -Call sndPlaySound(FileName, &H1 Or &H8 Or &H2) -End Function - -Public Function StopWAV() -Call sndStopSound(0, &H1) -End Function - -Public Sub PClear(PB As PictureBox) -PB.Picture = LoadPicture() -PB.Cls -End Sub - -Public Sub PClearV(PB As Variant) -PB.Picture = LoadPicture() -PB.Cls -End Sub - -Public Function GetDISKAll(drive As String) As Currency -Dim TotalBytes As Currency, BytesAvailableToCaller As Currency, FreeBytes As Currency, Status -Status = GetDiskFreeSpaceEx(drive, BytesAvailableToCaller, TotalBytes, FreeBytes) -GetDISKAll = TotalBytes -End Function - -Public Function GetDISKFree(drive As String) As Currency -Dim TotalBytes As Currency, BytesAvailableToCaller As Currency, FreeBytes As Currency, Status -Status = GetDiskFreeSpaceEx(drive, BytesAvailableToCaller, TotalBytes, FreeBytes) -GetDISKFree = FreeBytes -End Function - -Public Function LoadRGN(FileName As String, hWnd As Long) As Long -Dim i As Integer, k As Long, REGION As Long -Open FileName For Binary As #1 - Get #1, , RGNC 'Óçíà¸ì ñêîëüêî âñåãî ëèíèé - ReDim RGNM(0 To RGNC - 1, 0 To 1) As Integer - ReDim RGN_API(0 To RGNC - 1) As POINTAPI 'Ïåðåîáúÿâëÿåì ìàññèâ - Get #1, , RGNM() '×èòàåì êîîðäèíàòû ëèíèé ñîõðàí¸ííûõ â ôàéë -Close #1 -k = RGNC - 1 '×òîáû ëèøíèé ðàç íå ïåðåñ÷èòûâàòü -For i = 0 To k 'Ïåðåâîäèì ñ÷èòàííûé ìàññèâ â ñòðóêòóðó POINTAPI - RGN_API(i).x = RGNM(i, 0) - RGN_API(i).y = RGNM(i, 1) -Next i -REGION = CreatePolygonRgn(RGN_API(0), k, 2) 'Ñîçäà¸ì ðåãèîí -LoadRGN = REGION -SetWindowRgn hWnd, REGION, True 'Ïðèìåíÿåì ðåãèîí íà îáúåêò -End Function - -Public Function CheckFile(Name As String) As Integer -Dim S As Long -S = GetFileAttributes(Name) -If S = -1 Then CheckFile = 0: Exit Function -If S And &H10 Then CheckFile = 2: Exit Function -CheckFile = 1 -End Function - -Public Function GetSHORT(LongFN As String) As String -Dim h As String, L As Long -h = String(3000, " ") -GetShortPathName LongFN, h, 3000 -L = InStr(1, h, Chr(0)) -If L = 0 Then GetSHORT = LongFN: Exit Function -GetSHORT = Mid$(h, 1, L - 1) -End Function - -Public Function GetLONGN(ShortFN As String) As String -On Error Resume Next -Dim i As Long, IC As Long, S As String, PP As String, SS As String - -S = LCase(GetSHORT(ShortFN)) -PP = DirFilterIN(GetPathOnlyIN(ShortFN)) + "\" -'IC = GetFilesCount(PP, "*") - -SS = Dir(PP, vbArchive Or vbHidden Or vbNormal Or vbReadOnly Or vbSystem) -'For i = 0 To IC -Do Until Len(SS) = 0 - 'ss = GetNumberFileName(PP, "*", i) - If LCase$(GetSHORT(PP + SS)) = S Then index = i: GetLONGN = PP + SS: Exit Function - SS = Dir -Loop -'Next i -GetLONGN = ShortFN -End Function - -Public Function GetLONG(ShortFN As String, Fi As FileListBox, Optional index As Long) As String -Dim i As Long, IC As Long, S As String - -S = LCase(GetSHORT(ShortFN)) -Fi.Path = DirFilterIN(GetPathOnlyIN(ShortFN)) + "\" -IC = Fi.ListCount - 1 -For i = 0 To IC - If LCase$(GetSHORT(DirFilterIN(Fi.Path) + "\" + Fi.List(i))) = S Then index = i: GetLONG = DirFilterIN(Fi.Path) + "\" + Fi.List(i): Exit Function -Next i -GetLONG = ShortFN -End Function - -Public Function DirFilterIN(DirName As String) As String -On Error Resume Next -If Mid$(DirName, Len(DirName), 1) = "\" Then - DirFilterIN = Mid$(DirName, 1, Len(DirName) - 1) -Else - DirFilterIN = DirName -End If -End Function - -Public Function LoadRGNeX(FileName As String, hWnd As Long) As Long -Dim i As Integer, k As Long, REGION As Long -Open FileName For Binary As #1 - Get #1, , RGNC 'Óçíà¸ì ñêîëüêî âñåãî ëèíèé - ReDim RGNM(0 To RGNC - 1, 0 To 1) As Integer - ReDim RGN_API(0 To RGNC - 1) As POINTAPI 'Ïåðåîáúÿâëÿåì ìàññèâ - Get #1, , RGNM() '×èòàåì êîîðäèíàòû ëèíèé ñîõðàí¸ííûõ â ôàéë -Close #1 -k = RGNC - 1 '×òîáû ëèøíèé ðàç íå ïåðåñ÷èòûâàòü -For i = 0 To k 'Ïåðåâîäèì ñ÷èòàííûé ìàññèâ â ñòðóêòóðó POINTAPI - RGN_API(i).x = RGNM(i, 0) - RGN_API(i).y = RGNM(i, 1) -Next i -REGION = CreatePolygonRgn(RGN_API(0), k, 2) 'Ñîçäà¸ì ðåãèîí -LoadRGNeX = REGION -SetWindowRgn hWnd, REGION, True 'Ïðèìåíÿåì ðåãèîí íà îáúåêò -End Function - -Public Function LoadRGNonly(FileName As String) As Long -Dim i As Integer, k As Long, REGION As Long -Open FileName For Binary As #1 - Get #1, , RGNC 'Óçíà¸ì ñêîëüêî âñåãî ëèíèé - ReDim RGNM(0 To RGNC - 1, 0 To 1) As Integer - ReDim RGN_API(0 To RGNC - 1) As POINTAPI 'Ïåðåîáúÿâëÿåì ìàññèâ - Get #1, , RGNM() '×èòàåì êîîðäèíàòû ëèíèé ñîõðàí¸ííûõ â ôàéë -Close #1 -k = RGNC - 1 '×òîáû ëèøíèé ðàç íå ïåðåñ÷èòûâàòü -For i = 0 To k 'Ïåðåâîäèì ñ÷èòàííûé ìàññèâ â ñòðóêòóðó POINTAPI - RGN_API(i).x = RGNM(i, 0) - RGN_API(i).y = RGNM(i, 1) -Next i -REGION = CreatePolygonRgn(RGN_API(0), k, 2) 'Ñîçäà¸ì ðåãèîí -LoadRGNonly = REGION -End Function - -Public Function DrawONRgn(p1 As PictureBox, p2 As Object, RNN As Long, x, y) -Dim i As Long, j As Long, clr As Long, h As Long, W As Long, A As Long, hDC1 As Long, hDC2 As Long, REGION As Long -h = p1.ScaleHeight: W = p1.ScaleWidth -'GetWindowRgn P1.hWnd, REGION -hDC1 = p1.hdc: hDC2 = p2.hdc -For i = 0 To W - For j = 0 To h - A = PtInRegion(RNN, i, j) - If Not A = 0 Then - clr = GetPixel(hDC1, i, j) - If clr >= 0 Then SetPixelV hDC2, x + i, y + j, clr - End If - Next j -Next i -End Function - -Public Function GetNEXT(Max, Current) As Integer -If Current = Max Then GetNEXT = 0: Exit Function -GetNEXT = Current + 1 -End Function - -Public Function GetPREV(Max, Current) As Integer -If Current = 0 Then GetPREV = Max: Exit Function -GetPREV = Current - 1 -End Function - -Public Function OnPerCent(Max, PER) -Dim k As Single -k = Max / 100 -OnPerCent = PER * k -End Function - -Public Function OnPerCentFAST(Max As Integer, PER As Integer) As Integer -On Error Resume Next -Dim k As Single -k = Max / 100 -OnPerCentFAST = PER * k -End Function - -Public Function ToBYTES(ST As String, ms() As Byte) As Long -Dim i As Long, sLen As Long, k As String -sLen = Len(ST) -ReDim ms(1 To sLen) As Byte -CopyMemory ms(1), ByVal ST, sLen -ToBYTES = sLen -End Function - -Public Function ToSTRING(ST As String, ms() As Byte) As Long -Dim i As Long, sLen As Long -sLen = UBound(ms) -ST = Space$(sLen) -CopyMemory ByVal ST, ms(1), sLen -ToSTRING = sLen -End Function - -Public Function ToSTringNZ(ST As String, ms() As Byte) As Long -Dim i As Long, sLen As Long -sLen = UBound(ms) -For i = 1 To sLen - If Not Chr(ms(i)) = 0 Then ST = ST + Chr(ms(i)) -Next i -ToSTringNZ = sLen -End Function - -Public Function VBCopyFile(fSource As String, fDest As String, buffer As Long, PB As PictureBox, Optional LaB As Label) -On Error Resume Next -Dim ms() As Byte, lG As Long, FSize As Long, T As Long, NL As Byte -Dim F1 As Long, F2 As Long -ReDim ms(1 To buffer) As Byte -lG = 1 -F1 = FreeFile -Open fSource For Binary Access Read As #F1 - F2 = FreeFile - Open fDest For Binary Access Write As #F2 - FSize = LOF(1) - Seek #F2, FSize - Seek #F2, 1 - Do - If lG + buffer < FSize Then - Get #F1, lG, ms() - Put #F2, lG, ms() - lG = lG + buffer - Else - T = FSize - (lG - 1) - ReDim ms(1 To T) As Byte - Get #F1, lG, ms() - Put #F2, lG, ms() - lG = FSize - Exit Do - End If - If lG >= FSize Then Exit Do - ProgB PB, FSize, 1, lG - DoEvents - Loop - Close #F2 -Close #F1 -End Function - -Public Function EncodePassword(pW As String, code As Byte, ToBYTES() As Integer) As Integer -Dim i As Integer, sLen As Integer -sLen = Len(pW) -ReDim ToBYTES(1 To sLen) As Integer -For i = 1 To sLen - ToBYTES(i) = (255 - Asc(Mid$(pW, i, 1))) * code -Next i -EncodePassword = sLen -End Function - -Public Function DecodePassword(code As Byte, FBYTES() As Integer) As String -Dim i As Integer, sLen As Integer, k As String -sLen = UBound(FBYTES) -For i = 1 To sLen - k = k & Chr(255 - (FBYTES(i) / code)) -Next i -DecodePassword = k -End Function - -Public Function GetKey(Key As Long) As Long -Dim h As Long -h = GetKeyState(Key) -If h < -2 Then GetKey = 1 Else GetKey = 0 -End Function - -Public Function GetKeyUP(Key As Long) As Long -Dim h As Long -h = GetKeyState(Key) -If h < -2 Then - Do - h = GetKeyState(Key) - DoEvents - Loop Until h > -2 - GetKeyUP = 1 -Else - GetKeyUP = 0 -End If -End Function - -Public Function GetTheMax(ByVal V1 As Integer, ByVal V2 As Integer) As Integer -If V1 > V2 Then GetTheMax = V1 Else GetTheMax = V2 -End Function - -Public Function GetTheMaxV(V1, V2) -If V1 > V2 Then GetTheMaxV = V1 Else GetTheMaxV = V2 -End Function - -Public Function GetTheMaxL(ByVal V1 As Long, ByVal V2 As Long) As Long -If V1 > V2 Then GetTheMaxL = V1 Else GetTheMaxL = V2 -End Function - -Public Function GetTheMin(ByVal V1 As Integer, ByVal V2 As Integer) As Integer -If V1 < V2 Then GetTheMin = V1 Else GetTheMin = V2 -End Function - -Public Function GetTheMinV(V1, V2) -If V1 < V2 Then GetTheMinV = V1 Else GetTheMinV = V2 -End Function - -Public Function GetTheMinL(ByVal V1 As Long, ByVal V2 As Long) As Long -If V1 < V2 Then GetTheMinL = V1 Else GetTheMinL = V2 -End Function - -Public Sub FileIconEx(sFilePath As String, uFlags As Long, objPB As PictureBox, x As Long, y As Long) -On Error Resume Next -Dim shfi As SHFILEINFO -objPB.Cls -SHGetFileInfo ByVal sFilePath, 0&, shfi, Len(shfi), &H100& Or uFlags -If uFlags And 1 Then - DrawIconEx objPB.hdc, x, y, shfi.hIcon, 16, 16, 0, 0, &H3 -Else - DrawIconEx objPB.hdc, x, y, shfi.hIcon, 32, 32, 0, 0, &H3 -End If -objPB.Refresh -DestroyIcon shfi.hIcon -End Sub - -Public Function FileIconH(sFilePath As String, uFlags As Long) As Long -On Error Resume Next -Dim shfi As SHFILEINFO -SHGetFileInfo ByVal sFilePath, 0&, shfi, Len(shfi), &H100& Or uFlags - -FileIconH = shfi.hIcon -End Function - -Public Function GetFileType(FN As String) As String -Dim shfi As SHFILEINFO, d As Long, k(1 To 4) As Byte, P(1 To 2) As Integer -Dim S As String, i As Byte -d = SHGetFileInfo(ByVal FN, 0, shfi, Len(shfi), &H2000) - -GetFileType = "ERROR" -If d = 0 Then Exit Function - -CopyMemory k(1), d, 4 - -For i = 1 To 2 - S = S + Chr(k(i)) -Next -If S = "MZ" Then GetFileType = "EXE_DOS": Exit Function -CopyMemory P(1), k(1), 4 -If S = "PE" And k(2) = 0 Then GetFileType = "EXE_CONSOLE": Exit Function -If (S = "PE" Or S = "NE") Then GetFileType = "EXE_WIN": Exit Function -End Function - -Public Sub FileIconPP(sFilePath As String, PB As Object, TP As PictureBox, Optional x As Long, Optional y As Long) -On Error Resume Next -Dim shfi As SHFILEINFO -objPB.Cls -SHGetFileInfo ByVal sFilePath, 0&, shfi, Len(shfi), &H100& Or uFlags - -DrawIconEx TP.hdc, 0, 0, shfi.hIcon, 32, 32, 0, 0, &H3 - -PB.PaintPicture TP.Image, x, y, 16, 16, 0, 0, 32, 32 - -PB.Refresh -DestroyIcon shfi.hIcon -End Sub - -Public Function FileIconPic(sFilePath As String) As IPicture -On Error Resume Next -Dim shfi As SHFILEINFO, g As Guid, PD As PictDesc -SHGetFileInfo ByVal sFilePath, 0&, shfi, Len(shfi), &H100& Or &H0 - -With g - .Data1 = &H20400 - .Data4(0) = &HC0 - .Data4(7) = &H46 -End With - -With PD - .cbSizeofStruct = Len(PDesc) - .picType = 3 - .hImage = shfi.hIcon -End With - -OleCreatePictureIndirect PD, g, 1, FileIconPic - -DestroyIcon shfi.hIcon -End Function - -Public Function FileIconHandle(sFilePath As String) As Long -On Error Resume Next -Dim shfi As SHFILEINFO, NewIcon As Long, ret As Long -ret = SHGetFileInfo(ByVal sFilePath, ByVal 0, shfi, Len(shfi), &H100& Or &H0) -NewIcon = CopyIcon(shfi.hIcon) -DestroyIcon shfi.hIcon -FileIconHandle = NewIcon -End Function - -Public Sub EndTask(hWnd As Long) -Dim x As Long, y As Long -GetWindowThreadProcessId hWnd, y -x = OpenProcess(&H1, 1, y) -TerminateProcess x, 0 -End Sub - -Public Sub EndTask2(hWnd As Long) -Dim x As Long, y As Long -GetWindowThreadProcessId hWnd, y -x = OpenProcess(&H1, 1, y) -TerminateProcess x, 0 -End Sub - -Public Sub KillTask(ProcessID As Long) -Dim x As Long -x = OpenProcess(&H1, 1, ProcessID) -TerminateProcess x, 0 -End Sub - -Public Sub FillDC(hWnd As Long, hdc As Long, Color As Long) -Dim hBr As Long, r As RECT, P As POINTAPI -GetWindowRect hWnd, r -ClientToScreen hWnd, P -r.Left = P.x -r.Top = P.y -hBr = CreateSolidBrush(Color) -FillRect hdc, r, hBr -End Sub - -Public Sub DrawLineAPI(DC As Long, X1 As Long, Y1 As Long, X2 As Long, Y2 As Long) -Dim A As POINTAPI -MoveToEx DC, X1, Y1, A -LineTo DC, X2, Y2 -End Sub - -Public Function InvN(Value) -InvN = Abs(CLng(Value) - 1) -End Function - -Public Function GetSign(Value As Long) As Long -If Value < 0 Then GetSign = -1 Else GetSign = 1 -End Function - -Public Function GetSign2(Value As Long) As Long -If Value < 0 Then - GetSign2 = -1 -ElseIf Value > 0 Then - GetSign2 = 1 -Else - GetSign2 = 0 -End If -End Function - -Public Function PasswordEncode(Pass As String) As String -Dim IC As Long, i As Long, S As String -IC = Len(Pass) -For i = 1 To IC - S = S + Chr(255 - Asc(Mid$(Pass, i, 1))) + Chr(Rnd * 255) -Next i -PasswordEncode = S -End Function - -Public Function PasswordDecode(Pass As String) As String -Dim IC As Long, i As Long, S As String -IC = Len(Pass) -For i = 1 To IC Step 2 - S = S + Chr(255 - Asc(Mid$(Pass, i, 1))) -Next i -PasswordDecode = S -End Function - -Public Function FillGet(INTERVAL As Long, Optional i As Long = 0) As Byte -If timeGetTime - TFill(i) >= INTERVAL Then TFill(i) = timeGetTime: FillGet = 1 Else FillGet = 0 -If timeGetTime < TFill(i) Then TFill(i) = timeGetTime -End Function - -Public Sub wait(INTERVAL As Long) -Dim L As Long -L = timeGetTime -Do - DoEvents -Loop Until timeGetTime - L > INTERVAL -End Sub - -Public Sub mKill(sFile As String) -On Error Resume Next -SetAttr sFile, vbNormal -Kill sFile -End Sub - -Public Function GetTempDir() As String -Dim S As String, A As Long -S = String(2000, " ") -GetTempPath 2000, S -A = InStr(1, S, Chr(0)) -If A = 0 Then GetTempDir = DirFilterIN(S) & "\" Else GetTempDir = DirFilterIN(Mid$(S, 1, A - 1)) & "\" -End Function - -Public Function WindowUnderCursor() As Long -Dim P As POINTAPI -GetCursorPos P -WindowUnderCursor = WindowFromPoint(P.x, P.y) -End Function - -Public Sub ArrayToArrayByte(Arr1() As Byte, Arr2() As Byte) -Dim LB As Long, UB As Long, aLen As Long -UB = UBound(Arr1) -LB = LBound(Arr1) -aLen = (UB - LB) + 1 - -ReDim Arr2(LB To UB) As Byte -CopyMemory Arr2(LB), Arr1(LB), aLen -End Sub - -Public Function IfMoreThenZero(Value) -If Value > 0 Then IfMoreThenZero = Value Else IfMoreThenZero = 0 -End Function - -Public Function IsPointInRect(x As Long, y As Long, RX1 As Long, RY1 As Long, RX2 As Long, RY2 As Long) As Byte -If x > RX1 Then - If x < RX2 Then - If y > RY1 Then - If y < RY2 Then - IsPointInRect = 1 - End If - End If - End If -End If -End Function - -Public Function IsPointInRectWH(x As Long, y As Long, RX1 As Long, RY1 As Long, WWW As Long, HHH As Long) As Byte -Dim RY2 As Long, RX2 As Long - -RX2 = RX1 + WWW -RY2 = RY1 + HHH - -If x > RX1 Then - If x < RX2 Then - If y > RY1 Then - If y < RY2 Then - IsPointInRectWH = 1 - End If - End If - End If -End If -End Function - -Public Sub BeginMeter() -BeginTime = timeGetTime -End Sub - -Public Function EndMeter() As Long -EndMeter = timeGetTime - BeginTime -End Function - -Public Function GetFilesCount(ByVal folder As String, Ext As String) As Long -Dim S As String -folder = DirFilterIN(folder) + "\*." + Ext -S = Dir(folder, vbArchive Or vbHidden Or vbNormal Or vbReadOnly Or vbSystem) -Do Until S = "" - GetFilesCount = GetFilesCount + 1 - S = Dir -Loop -End Function - -Public Function GetNumberFileName(ByVal folder As String, Ext As String, Num As Long) As String -Dim S As String, i As Long -folder = DirFilterIN(folder) + "\*." + Ext -S = Dir(folder, vbArchive Or vbHidden Or vbNormal Or vbReadOnly Or vbSystem) -Do Until S = "" - i = i + 1 - If i = Num Then GetNumberFileName = S - S = Dir -Loop -End Function - -Public Function TrayAdd(TrayObj As PictureBox, Optional ToolTip As String, Optional Icon As Long) As Long -With nfIconData - .hWnd = TrayObj.hWnd - .uId = 0 - .uFlags = Icon_Flags.Icon Or Icon_Flags.message Or Icon_Flags.Tip - .uCallbackMessage = WM_MOUSEMOVE - .hIcon = TrayObj.Picture.handle - If Not Icon = 0 Then .hIcon = Icon - ' .hIcon = TrayObj.Image.Handle - .szTip = ToolTip & vbNullChar - .cbSize = Len(nfIconData) -End With -TrayAdd = Shell_NotifyIcon(NIM_ADD, nfIconData) -End Function - -Public Sub TrayModify(TrayObj As PictureBox, Optional ToolTip As String, Optional Icon As Long) -With nfIconData - .hWnd = TrayObj.hWnd - .uFlags = Icon_Flags.Icon Or Icon_Flags.message Or Icon_Flags.Tip - .uCallbackMessage = WM_MOUSEMOVE - .hIcon = TrayObj.Picture.handle - If Not Icon = 0 Then .hIcon = Icon - ' .hIcon = TrayObj.Image.Handle - .szTip = ToolTip & vbNullChar - .cbSize = Len(nfIconData) -End With -If Shell_NotifyIcon(Action.MODIFY, nfIconData) = 0 Then - Shell_NotifyIcon Action.Add, nfIconData -End If -End Sub - -Public Sub TrayBalloon(TrayObj As PictureBox, strTitle As String, IconType As Long, strMessage As String) - - With nidBalloon - .cbSize = Len(nidBalloon) - .hWnd = TrayObj.hWnd - ' .uId = App.hInstance - .uFlags = Icon_Flags.Info - .dwInfoFlags = IconType - .szInfoTitle = strTitle + Chr(0) - .szInfo = strMessage + Chr(0) - End With - - Call Shell_NotifyIcon(Action.MODIFY, nidBalloon) - -End Sub - -Public Sub TrayRemove() -Call Shell_NotifyIcon(Action.Delete, nfIconData) -End Sub - -Public Sub DeleteBalloon(TrayObj As PictureBox) - Call Shell_NotifyIcon(Action.Delete, nidBalloon) -End Sub - -Public Function mRND(ToNumber As Long) As Long -mRND = timeGetTime Mod ToNumber -End Function - -Public Function GetPAD(N, To1 As String, To4 As String, To0 As String) As String -Dim M As String, k As Long, d As Long -M = Mid$(Format$(N), Len(Format$(N)), 1) -If Len(Format$(N)) > 1 Then - d = Val(Mid$(Format$(N), Len(Format$(N)) - 1, 2)) -Else - d = N -End If -k = Val(M) -If d > 10 And d < 20 Then k = 0 -Select Case k - Case 1: GetPAD = To1 - Case 2, 3, 4: GetPAD = To4 - Case Else: GetPAD = To0 -End Select -End Function - -Public Function ToPoint(ByVal S As String) As String -Dim i As Long, IC As String -IC = Len(S) -For i = 1 To IC - If Mid$(S, i, 1) = "," Then Mid$(S, i, 1) = "." -Next -ToPoint = S -End Function - -Public Sub GetPictureWH(handle As Long, Width As Long, Height As Long, Optional bits As Long) -Dim BM As BITMAP -GetObjectAPI handle, Len(BM), BM -Width = BM.bmWidth -Height = BM.bmHeight -bits = BM.bmBitsPixel -End Sub - -Public Function GetPictureBitCount(handle As Long) As Long -Dim BM As BITMAP -GetObjectAPI handle, Len(BM), BM -GetPictureBitCount = BM.bmBitsPixel -End Function - -Public Function LoadTextFile(FileName As String) As String -Dim f As Long -f = FreeFile -Open FileName For Input As f - LoadTextFile = Input$(LOF(f), f) -Close f -End Function - -Public Function LoadFile(FileName As String) As String -Dim f As Long, B() As Byte, IC As Long -f = FreeFile -If CheckFile(FileName) <> 1 Then Exit Function -Open FileName For Binary As f - IC = LOF(f) - If Not IC = 0 Then - ReDim B(1 To IC) As Byte - Get #f, 1, B() - LoadFile = String(IC, " ") - CopyMemory ByVal LoadFile, B(1), IC - End If -Close f -End Function - -Public Function LoadFileB(FileName As String, ToArr() As Byte, Optional Max As Long = -1) As Long -Dim f As Long, IC As Long -f = FreeFile -Open FileName For Binary As f - IC = LOF(f) - If IC > Max And Max >= 0 Then IC = Max - If Not IC = 0 Then - ReDim ToArr(1 To IC) As Byte - Get #f, 1, ToArr() - LoadFileB = IC - End If -Close f -End Function - -Public Sub SaveFile(FileName As String, Text As String) -Dim f As Long, ms() As Byte, IC As Long -f = FreeFile -Open FileName For Output As f -Close f -Open FileName For Binary Access Write As f - If f = FreeFile Then Exit Sub - IC = Len(Text) - If Not IC = 0 Then - ReDim ms(1 To IC) As Byte - CopyMemory ms(1), ByVal Text, IC - Put #f, 1, ms() - End If -Close f -End Sub - -Public Sub SaveFileB(FileName As String, Arr() As Byte) -On Error Resume Next -Dim f As Long, IC As Long -f = FreeFile -Open FileName For Output As f -Close f -Open FileName For Binary Access Write As f - If f = FreeFile Then Exit Sub - IC = UBound(Arr) - If Not IC = 0 Then - Put #f, 1, Arr() - End If -Close f -End Sub - -Public Sub SaveControl(ctrl As Control, Optional Section As String = "SavedC") -On Error Resume Next -Dim i As Long -i = ctrl.index - -SaveSetting App.EXEName, Section, ctrl.Name & i & " value", ctrl.Value -SaveSetting App.EXEName, Section, ctrl.Name & i & " caption", ctrl.Caption -SaveSetting App.EXEName, Section, ctrl.Name & i & " text", ctrl.Text -SaveSetting App.EXEName, Section, ctrl.Name & i & " backcolor", ctrl.BackColor -SaveSetting App.EXEName, Section, ctrl.Name & i & " forecolor", ctrl.ForeColor -SaveSetting App.EXEName, Section, ctrl.Name & i & " listindex", ctrl.ListIndex -SaveSetting App.EXEName, Section, ctrl.Name & i & " checked", ctrl.Checked -End Sub - -Public Sub LoadControl(ctrl As Control, Optional Section As String = "SavedC") -On Error Resume Next -Dim i As Long -i = ctrl.index - -ctrl.Value = Val(GetSetting(App.EXEName, Section, ctrl.Name & i & " value", ctrl.Value)) -ctrl.ListIndex = Val(GetSetting(App.EXEName, Section, ctrl.Name & i & " listindex", ctrl.ListIndex)) -ctrl.Caption = GetSetting(App.EXEName, Section, ctrl.Name & i & " caption", ctrl.Caption) -ctrl.Text = GetSetting(App.EXEName, Section, ctrl.Name & i & " text", ctrl.Text) -ctrl.BackColor = Val(GetSetting(App.EXEName, Section, ctrl.Name & i & " backcolor", ctrl.BackColor)) -ctrl.ForeColor = Val(GetSetting(App.EXEName, Section, ctrl.Name & i & " forecolor", ctrl.ForeColor)) -ctrl.Checked = CBool(GetSetting(App.EXEName, Section, ctrl.Name & i & " checked", ctrl.Checked)) - Exit Sub -End Sub - -Public Sub LoadControlR(ctrl As Control, Optional Section As String = "SavedC", Optional NoText As Boolean) -On Error Resume Next -Dim i As Long -i = ctrl.index - -ctrl.Value = CBool(GetSetting(App.EXEName, Section, ctrl.Name & i & " value", ctrl.Value)) -ctrl.ListIndex = Val(GetSetting(App.EXEName, Section, ctrl.Name & i & " listindex", ctrl.ListIndex)) -If Not NoText Then ctrl.Caption = GetSetting(App.EXEName, Section, ctrl.Name & i & " caption", ctrl.Caption) -If Not NoText Then ctrl.Text = GetSetting(App.EXEName, Section, ctrl.Name & i & " text", ctrl.Text) -ctrl.BackColor = Val(GetSetting(App.EXEName, Section, ctrl.Name & i & " backcolor", ctrl.BackColor)) -ctrl.ForeColor = Val(GetSetting(App.EXEName, Section, ctrl.Name & i & " forecolor", ctrl.ForeColor)) -End Sub - - -Public Function PictureFromImage(picImage As IPictureDisp) As StdPicture -Dim TP As String -TP = DirFilterIN(GetTempDir) + "\tmp0456.bmp" -SavePicture picImage, TP -Set PictureFromImage = LoadPicture(TP) -mKill TP -End Function - -Public Function RGBWidth(Width As Long) As Long -RGBWidth = (Width * 3 + 3) And &HFFFFFFFC -End Function - -Public Function MaskWidth(W As Long) As Long -MaskWidth = ((((W + 7) \ 8) + 3) And &HFFFFFFFC) -End Function - -Public Function Username() As String -On Error Resume Next -Dim S As String * 1000, A As Long -GetUserName S, Len(S) -A = InStr(1, S, Chr(0)) -If Not A = 0 Then Username = Mid$(S, 1, A - 1) Else Username = S -End Function - -Public Sub ShowErrorMsg(Msg As String) -MsgBox Msg, vbCritical, "Îøèáêà" -End Sub - -Public Function fDiv(ByVal V1, ByVal V2) -Dim A As Long, B As Long - -A = 389 \ 17 -A = CLng(V1) \ CLng(V2) -B = CLng(V1) Mod CLng(V2) -If B > 0 Then A = A + 1 -fDiv = A -End Function - -Public Function FPSMS(FPS As Long) As Long -FPSMS = 1000 / FPS -End Function - -Public Function DownUp(OldV, NewV, MinS As String, MaxS As String, RavS As String) As String -If OldV > NewV Then - DownUp = MinS -ElseIf OldV < NewV Then - DownUp = MaxS -Else - DownUp = RavS -End If -End Function - -Public Sub DrawRNDLineH(DC As Long, y As Long, Width As Long, Optional MaxRND As Long = -1) -Dim i As Long, Py As Long - -Py = y - -For i = 0 To Width - SetPixelV DC, i, Py, 0 - Py = Py + (Rnd * 2) - 1 - If Py > y + MaxRND And Not MaxRND = -1 Then - Py = Py - 1 - ElseIf Py < y - MaxRND And Not MaxRND = -1 Then - Py = Py + 1 - End If -Next -End Sub - -Public Sub DrawRNDLineV(DC As Long, x As Long, Height As Long, Optional MaxRND As Long = -1) -Dim i As Long, Px As Long - -Px = x - -For i = 0 To Height - SetPixelV DC, Px, i, 0 - Px = Px + (Rnd * 2) - 1 - If Px > x + MaxRND And Not MaxRND = -1 Then - Px = Px - 1 - ElseIf Px < x - MaxRND And Not MaxRND = -1 Then - Px = Px + 1 - End If -Next -End Sub - -Public Sub FillPB(PB As PictureBox, x As Long, y As Long, Color As Long) -Dim OldFillStyle As Long, OldFillColor As Long - -OldFillStyle = PB.FillStyle -OldFillColor = PB.FillColor -PB.FillStyle = 0 -PB.FillColor = Color - -ExtFloodFill PB.hdc, x, y, PB.Point(x, y), 1 - -PB.FillStyle = OldFillStyle -PB.FillColor = OldFillColor -End Sub - -Public Function CheckByValue(V1, V2, Optional Value = 1) As Boolean -CheckByValue = False -If V1 + Value >= V2 Then - If V1 - Value <= V2 Then - CheckByValue = True - End If -End If -End Function - -Public Sub NeedSleep(ms As Long) -Dim L As Long -L = timeGetTime - BeginTime -If ms > L And L > 0 Then 'Sleep MS - L - Do Until (EndMeter >= ms) Or (EndMeter < 0) - Loop -End If -End Sub - -Public Function GetWindowIcon(hWnd As Long, Optional iType As Long = 1) As Long -GetWindowIcon = DefWindowProc(hWnd, &H7F, iType, 0) -End Function - -Public Function SetWindowIcon(hWnd As Long, hIcon As Long, Optional iType As Long = 0) As Long -SetWindowIcon = DefWindowProc(hWnd, &H80, iType, hIcon) -End Function - -Public Function NoZeroS(Text As String) As String -Dim A As Long -A = InStr(1, Text, Chr$(0)) -If A = 0 Then - NoZeroS = Text -ElseIf A = 1 Then - NoZeroS = "" -Else - NoZeroS = Mid$(Text, 1, A - 1) -End If -End Function - -Public Function NoLastS(Text As String) As String -Dim i As Long, IC As Long - -IC = Len(Text) -For i = IC To 1 Step -1 - If Not Mid$(Text, i, 1) = " " Then NoLastS = Mid$(Text, 1, i): Exit Function -Next - -NoLastS = "" -Exit Function -End Function - -Public Function IsNothing(Obj As Object) As Boolean -Dim A As Long -CopyMemory A, Obj, 4 -If A = 0 Then IsNothing = True Else IsNothing = False -End Function - -Public Function ObjectPtr(Obj As Object) As Long -Dim A As Long -CopyMemory A, Obj, 4 -ObjectPtr = A -End Function - -Public Sub mRefresh(Obj As Object) -Dim DC As Long, r As RECT - -DC = GetDC(Obj.hWnd) -GetClientRect hWnd, r -BitBlt DC, 0, 0, r.Right, r.Bottom, Obj.hdc, 0, 0, vbSrcCopy -End Sub - -Public Sub mDoEvents2(hWnd As Long) -Dim M As Msg - -If GetMessage(M, hWnd, 0, 0) Then - TranslateMessage M - DispatchMessage M -End If -End Sub - -'Public Sub DoEvents2(hwnd As Long) -'Dim M As Msg -' -'If GetMessage(M, hwnd, 0, 0) Then -' TranslateMessage M -' DispatchMessage M -'End If - -'End Sub -Public Sub mDoEvents(hWnd As Long) -Dim M As Msg -If Not PeekMessage(M, hWnd, 0, &H500, &H0) = 0 Then DoEvents -End Sub - -Public Sub Inc(ByRef Value, ByValue) -Value = Value + ByValue -End Sub - -Public Sub mGet(vbFile As Long, ms() As Byte, ByVal Count As Long, Optional BytesRead As Long) -Dim M() As Byte, FR As Long, TP As Long -FR = (LOF(vbFile) - Seek(vbFile)) - 1 -If Count > FR Then Count = FR -TP = Seek(vbFile) -ReDim M(1 To Count) As Byte -Get vbFile, , M() -Seek vbFile, TP + Count -CopyMemory ms(LBound(ms)), M(1), Count -BytesRead = Count -End Sub - -Public Sub mPut(vbFile As Long, ms() As Byte, Count As Long) -Dim M() As Byte, TP As Long -ReDim M(1 To Count) As Byte -CopyMemory M(1), ms(LBound(ms)), Count -TP = Seek(vbFile) -Put vbFile, , M() -Seek vbFile, TP + Count -End Sub - -Public Sub PErase(PB As PictureBox, Optional WithoutPicture As Byte) -PB.Line (0, 0)-(PB.ScaleWidth, PB.ScaleHeight), PB.BackColor, BF -PB.CurrentX = 0 -PB.CurrentY = 0 -If Not PB.Picture.handle = 0 And WithoutPicture = 0 Then PB.PaintPicture PB.Picture, 0, 0 -End Sub - -Public Sub PEraseObj(PB As Object, Optional WithoutPicture As Byte) -PB.Line (0, 0)-(PB.ScaleWidth, PB.ScaleHeight), PB.BackColor, BF -PB.CurrentX = 0 -PB.CurrentY = 0 -If Not PB.Picture.handle = 0 And WithoutPicture = 0 Then PB.PaintPicture PB.Picture, 0, 0 -End Sub - -Public Function ToLong(RGB As pRGB) As Long -CopyMemory ToLong, RGB, 4 -End Function - -Public Sub FixFloat(S As String) -S = Replace(S, ",", ".", , , vbTextCompare) -End Sub - -Public Function FixFloatF(S As String) As String -FixFloatF = Replace(S, ",", ".", , , vbTextCompare) -End Function - -Public Sub ReDimStr(S As String, Size As Long) -If Size <= 1 Then Exit Sub -S = String$(Size, " ") -End Sub - -Public Function FileInStr(vbFile As Long, Text As String, Optional ByVal StartPos As Long = 1, Optional noCase As Byte = 0, Optional BufferSize As Long = 512) As Long -Dim M() As Byte, S As String, TL As Long, r As Long -Dim i As Long, IC As Long, sz As Long, BST As Long - -If StartPos < 1 Then StartPos = 1 - -TL = Len(Text) -IC = LOF(vbFile) -BST = BufferSize - TL -For i = StartPos To IC Step BST - sz = IC - (i - 1) - If sz > BufferSize Then sz = BufferSize - If Not Len(S) = sz Then - ReDim M(1 To sz) As Byte - ReDimStr S, sz - End If - - Get vbFile, i, M() - CopyMemory ByVal S, M(1), sz - - If noCase = 0 Then - r = InStr(1, S, Text, vbBinaryCompare) - Else - r = InStr(1, S, Text, vbTextCompare) - End If - If Not r = 0 Then FileInStr = (i - 1) + r: Exit Function -Next -FileInStr = -1 -End Function - - - -Public Sub GradV2(PB As PictureBox, x As Long, y As Long, W As Long, h As Long, Color1 As Long, Color2 As Long) -Dim R1 As Single, G1 As Single, B1 As Single -Dim R2 As Single, G2 As Single, b2 As Single - -Dim i As Long, IC As Long, RStep As Single, GStep As Single, BStep As Single - -GetRGB Color1, R1, G1, B1 -GetRGB Color2, R2, G2, b2 - -IC = h \ 2 -RStep = (R2 - R1) / CSng(IC) -GStep = (G2 - G1) / CSng(IC) -BStep = (b2 - B1) / CSng(IC) -For i = 0 To IC - PB.Line (x, y + i)-(x + W, y + i), RGB(R1, G1, B1) - R1 = R1 + RStep - G1 = G1 + GStep - B1 = B1 + BStep -Next - - -GetRGB Color2, R1, G1, B1 -GetRGB Color1, R2, G2, b2 - -RStep = (R2 - R1) / CSng(IC) -GStep = (G2 - G1) / CSng(IC) -BStep = (b2 - B1) / CSng(IC) -For i = 0 To IC - PB.Line (x, y + i + IC)-(x + W, y + i + IC), RGB(R1, G1, B1) - R1 = R1 + RStep - G1 = G1 + GStep - B1 = B1 + BStep -Next -End Sub - -Public Function PBBitmapInfo(PB As PictureBox) As BITMAPINFO -PBBitmapInfo.bmiHeader.biSize = 40 -PBBitmapInfo.bmiHeader.biWidth = PB.ScaleWidth -PBBitmapInfo.bmiHeader.biHeight = PB.ScaleHeight -PBBitmapInfo.bmiHeader.biPlanes = 1 -PBBitmapInfo.bmiHeader.biBitCount = 24 -PBBitmapInfo.bmiHeader.biCompression = 0 -PBBitmapInfo.bmiHeader.biSizeImage = 0 -End Function - -Public Function ArrayDataPointer(ArrayPointer As Long) As Long -Dim U2 As Long, U3 As Long, tSA As SAFEARRAY - -U2 = VarPtr(tSA) -CopyMemory U3, ByVal ArrayPointer, 4 -CopyMemory ByVal U2, ByVal U3, Len(tSA) - -ArrayDataPointer = tSA.pvData -End Function - - -Public Sub vbBitBltTransparent(DestPB As PictureBox, DestX As Long, DestY As Long, Width As Long, Height As Long, SrcPB As PictureBox, SrcX As Long, SrcY As Long, ByVal alpha As Single) -Dim i As Long, j As Long, CR As nRGB, CD As nRGB -Dim r As Integer, g As Integer, B As Integer, HA As Single, clr As Long - -If Not DestPB.ScaleMode = 3 Then DestPB.ScaleMode = 3 -If Not SrcPB.ScaleMode = 3 Then SrcPB.ScaleMode = 3 - -Dim DestDC As Long, DestBitmap As Long, SrcDC As Long, SrcBitmap As Long -Dim DestBI As BITMAPINFO, SrcBI As BITMAPINFO, dH As Long, Sh As Long, dw As Long -Dim sArr() As nRGB, dArr() As nRGB, T1 As Long, T2 As Long - -ReDim sArr(0 To SrcPB.ScaleWidth) As nRGB, dArr(0 To DestPB.ScaleWidth) As nRGB - -dH = DestPB.ScaleHeight - 1 -dw = DestPB.ScaleWidth -Sh = SrcPB.ScaleHeight - 1 -DestDC = DestPB.hdc -DestBitmap = DestPB.Image.handle -SrcDC = SrcPB.hdc -SrcBitmap = SrcPB.Image.handle -DestBI = PBBitmapInfo(DestPB) -SrcBI = PBBitmapInfo(SrcPB) - -If alpha < 0 Then alpha = 0 -If alpha > 1 Then alpha = 1 -HA = 1 - alpha - -For j = 0 To Height - GetDIBits SrcDC, SrcBitmap, Sh - (j + SrcY), 1, ByVal ArrayDataPointer(VarPtrArray(sArr())), SrcBI, 0 - GetDIBits DestDC, DestBitmap, dH - (j + DestY), 1, ByVal ArrayDataPointer(VarPtrArray(dArr())), DestBI, 0 - For i = 0 To Width - T1 = DestX + i - If Not T1 > dw And Not T1 < 0 Then - T2 = SrcX + i - dArr(T1).r = sArr(T2).r * HA + dArr(T1).r * alpha - dArr(T1).g = sArr(T2).g * HA + dArr(T1).g * alpha - dArr(T1).B = sArr(T2).B * HA + dArr(T1).B * alpha - End If - Next - SetDIBits DestDC, DestBitmap, dH - (j + DestY), 1, ByVal ArrayDataPointer(VarPtrArray(dArr())), DestBI, 0 -Next -End Sub - -Public Sub vbBitBltTransparentColor(DestPB As PictureBox, DestX As Long, DestY As Long, Width As Long, Height As Long, SrcPB As PictureBox, SrcX As Long, SrcY As Long, ByVal TColor As Long) -Dim i As Long, j As Long, CR As nRGB, CD As nRGB -Dim r As Integer, g As Integer, B As Integer, HA As Single, clr As Long - -If Not DestPB.ScaleMode = 3 Then DestPB.ScaleMode = 3 -If Not SrcPB.ScaleMode = 3 Then SrcPB.ScaleMode = 3 - -Dim DestDC As Long, DestBitmap As Long, SrcDC As Long, SrcBitmap As Long -Dim DestBI As BITMAPINFO, SrcBI As BITMAPINFO, dH As Long, Sh As Long, dw As Long -Dim sArr() As nRGB, dArr() As nRGB, T1 As Long, T2 As Long - -ReDim sArr(0 To SrcPB.ScaleWidth) As nRGB, dArr(0 To DestPB.ScaleWidth) As nRGB - -dH = DestPB.ScaleHeight - 1 -dw = DestPB.ScaleWidth -Sh = SrcPB.ScaleHeight - 1 -DestDC = DestPB.hdc -DestBitmap = DestPB.Image.handle -SrcDC = SrcPB.hdc -SrcBitmap = SrcPB.Image.handle -DestBI = PBBitmapInfo(DestPB) -SrcBI = PBBitmapInfo(SrcPB) - -GetRGB TColor, r, g, B - -For j = 0 To Height - GetDIBits SrcDC, SrcBitmap, Sh - (j + SrcY), 1, ByVal ArrayDataPointer(VarPtrArray(sArr())), SrcBI, 0 - GetDIBits DestDC, DestBitmap, dH - (j + DestY), 1, ByVal ArrayDataPointer(VarPtrArray(dArr())), DestBI, 0 - For i = 0 To Width - T1 = DestX + i - If Not T1 > dw And Not T1 < 0 Then - T2 = SrcX + i - If (Not sArr(T2).r = r) Or (Not sArr(T2).g = g) Or (Not sArr(T2).B = B) Then - dArr(T1) = sArr(T2) - End If - End If - Next - SetDIBits DestDC, DestBitmap, dH - (j + DestY), 1, ByVal ArrayDataPointer(VarPtrArray(dArr())), DestBI, 0 -Next -End Sub - -Public Sub StringPut(f As Long, Optional Pos As Long = -1, Optional PutString As String) -Dim L As Long, B() As Byte - -L = Len(PutString) -If Not L = 0 Then ReDim B(1 To L) As Byte: CopyMemory B(1), ByVal PutString, L - -If Pos > 0 Then - Put f, , L - If Not L = 0 Then Put f, , B() -Else - Put f, Pos, L - If Not L = 0 Then Put f, Pos + 4, B() -End If -End Sub - -Public Sub StringGet(f As Long, Optional Pos As Long = -1, Optional GetString As String) -Dim L As Long, B() As Byte - -GetString = "" - -If Pos > 0 Then - Get f, , L - If Not L = 0 Then - ReDim B(1 To L) As Byte - Get f, , B() - GetString = String(L, " ") - CopyMemory ByVal GetString, B(1), L - End If -Else - Get f, Pos, L - If Not L = 0 Then - ReDim B(1 To L) As Byte - Get f, Pos + 4, B() - GetString = String(L, " ") - CopyMemory ByVal GetString, B(1), L - End If -End If -End Sub - -Public Function cWidth(hWnd As Long) As Long -Dim r As RECT -GetClientRect hWnd, r -cWidth = r.Right -End Function - -Public Function cHeight(hWnd As Long) As Long -Dim r As RECT -GetClientRect hWnd, r -cHeight = r.Bottom -End Function - -Public Function GetFileText(FileName As String) As String -Dim f As Long -f = FreeFile -Open FileName For Input As f - - GetFileText = Input$(LOF(f), #f) -Close f -End Function - -Public Sub SetFileText(FileName As String, Text As String) -Dim f As Long -f = FreeFile -Open FileName For Output As #f - Print #f, Text -Close #f -End Sub - -Public Sub GetPictureWHEx(Pic As StdPicture, Optional Width As Long, Optional Height As Long) -Dim BM As BITMAP, Icon As ICONINFO, hWnd As Long -If Pic.Type = 1 Then - hWnd = Pic.handle -ElseIf Pic.Type = 3 Then - GetIconInfo Pic.handle, Icon - hWnd = Icon.hBmColor -End If - -If hWnd = 0 Then Exit Sub - -GetObjectAPI hWnd, Len(BM), BM -Width = BM.bmWidth -Height = BM.bmHeight - -If Pic.Type = 3 Then - DeleteObject Icon.hBmColor - DeleteObject Icon.hBmMask -End If -End Sub - -Public Function CreateDIB(ByVal lHDC As Long, ByVal lWidth As Long, ByVal lheight As Long, BitsPointer As Long, Optional BitsPerPixel As Long = 24) As Long -Dim m_tBI As BITMAPINFO -With m_tBI.bmiHeader - .biSize = Len(m_tBI.bmiHeader) - .biWidth = lWidth - .biHeight = lheight - .biPlanes = 1 - .biBitCount = BitsPerPixel - .biCompression = BI_RGB - If Not bits = 1 Then - .biSizeImage = RGBWidth(lWidth) * .biHeight - Else - .biSizeImage = MaskWidth(lWidth) * .biHeight - End If -End With -CreateDIB = CreateDIBSection(lHDC, m_tBI, DIB_RGB_COLORS, BitsPointer, 0, 0) -End Function - -Public Function CreatetPictureFromFile(FileName As String, Optional TColor As Long = -1) As tPicture -Dim Pic As StdPicture -Set Pic = LoadPicture(FileName) - -CreatetPictureFromFile = CreatetPicture(Pic, TColor) -End Function - -Public Function CopyhBmp(hBMP As Long) As Long -CopyhBmp = CopyImage(hBMP, IMAGE_BITMAP, 0, 0, &H4) -End Function - -Public Function CreateEmptytPicture(Width As Long, Height As Long, Optional Dib24Bit As Byte) As tPicture -Dim MaskColor As Long, hPal As Long -Dim cBk As Long, cText As Long -Dim tDC As Long, tBitmap As Long, tBO As Long, BPS As Long - -hDcScreen = CreateCompatibleDC(0) 'GetDC(0&) -hPal = CreateHalftonePalette(hDcScreen) -OleTranslateColor TColor, hPal, MaskColor - -CreateEmptytPicture.Width = Width -CreateEmptytPicture.Height = Height -CreateEmptytPicture.PDC = CreateCompatibleDC(0) -If Dib24Bit = 0 Then - BPS = GetDeviceCaps(CreateEmptytPicture.PDC, BITSPIXEL) - CreateEmptytPicture.pBitmap = CreateBitmap(CreateEmptytPicture.Width, CreateEmptytPicture.Height, 1, BPS, ByVal 0&) - 'CreateEmptytPicture.pBitmap = CreateCompatibleBitmap(CreateEmptytPicture.PDC, CreateEmptytPicture.Width, CreateEmptytPicture.height) - CreateEmptytPicture.OldpBitmap = SelectObject(CreateEmptytPicture.PDC, CreateEmptytPicture.pBitmap) -Else - CreateEmptytPicture.pBitmap = CreateDIB(CreateEmptytPicture.PDC, CreateEmptytPicture.Width, CreateEmptytPicture.Height, CreateEmptytPicture.pBitmapBits, 24) - CreateEmptytPicture.OldpBitmap = SelectObject(CreateEmptytPicture.PDC, CreateEmptytPicture.pBitmap) -End If -End Function - -Public Function CreatetPictureFromIcon(hIcon As Long) As tPicture -Dim ICN As ICONINFO - -GetIconInfo hIcon, ICN - -CreatetPictureFromIcon.pBitmap = ICN.hBmColor -CreatetPictureFromIcon.PDC = CreateCompatibleDC(0) -CreatetPictureFromIcon.OldpBitmap = SelectObject(CreatetPictureFromIcon.PDC, CreatetPictureFromIcon.pBitmap) - -CreatetPictureFromIcon.mBitmap = ICN.hBmMask -CreatetPictureFromIcon.mDC = CreateCompatibleDC(0) -CreatetPictureFromIcon.OldmBitmap = SelectObject(CreatetPictureFromIcon.mDC, CreatetPictureFromIcon.mBitmap) -End Function - -Public Function CreatetPicture(Pic As StdPicture, TColor As Long, Optional Dib24Bit As Byte, Optional NoSelectToDC As Boolean) As tPicture -Dim MaskColor As Long, hPal As Long -Dim cBk As Long, cText As Long -Dim tDC As Long, tBitmap As Long, tBO As Long - -hDcScreen = CreateCompatibleDC(0) 'GetDC(0&) -hPal = CreateHalftonePalette(hDcScreen) -OleTranslateColor TColor, hPal, MaskColor - -'Color -GetPictureWH Pic.handle, CreatetPicture.Width, CreatetPicture.Height -CreatetPicture.PDC = CreateCompatibleDC(0) -If Dib24Bit = 0 Then - CreatetPicture.pBitmap = CopyImage(Pic.handle, IMAGE_BITMAP, 0, 0, &H4) - CreatetPicture.OldpBitmap = SelectObject(CreatetPicture.PDC, CreatetPicture.pBitmap) -Else - tDC = CreateCompatibleDC(0) - tBitmap = CopyImage(Pic.handle, IMAGE_BITMAP, 0, 0, &H4) - tBO = SelectObject(tDC, tBitmap) - - CreatetPicture.pBitmap = CreateDIB(CreatetPicture.PDC, CreatetPicture.Width, CreatetPicture.Height, CreatetPicture.pBitmapBits, 24) - CreatetPicture.OldpBitmap = SelectObject(CreatetPicture.PDC, CreatetPicture.pBitmap) - BitBlt CreatetPicture.PDC, 0, 0, CreatetPicture.Width, CreatetPicture.Height, tDC, 0, 0, vbSrcCopy - - DeleteObject SelectObject(tDC, tBitmap) - DeleteObject tBitmap - DeleteDC tDC -End If - -If NoSelectToDC Then - DeleteObject SelectObject(CreatetPicture.PDC, CreatetPicture.OldpBitmap) -End If - -'SetBkColor CreatetPicture.PDC, cBk -'SetTextColor CreatetPicture.PDC, cText -'BitBlt CreatetPicture.PDC, 0, 0, CreatetPicture.Width, CreatetPicture.height, CreatetPicture.mDC, 0, 0, &H220326 - -If TColor = -1 Then Exit Function -'Mask -CreatetPicture.mDC = CreateCompatibleDC(0) -CreatetPicture.mBitmap = CreateBitmap(CreatetPicture.Width, CreatetPicture.Height, 1, 1, ByVal 0&) -CreatetPicture.OldmBitmap = SelectObject(CreatetPicture.mDC, CreatetPicture.mBitmap) - -cBk = GetBkColor(CreatetPicture.PDC) -cText = GetTextColor(CreatetPicture.PDC) - -SetBkColor CreatetPicture.mDC, TColor -SetTextColor CreatetPicture.mDC, vbWhite -SetBkColor CreatetPicture.PDC, TColor -SetTextColor CreatetPicture.PDC, vbWhite - -BitBlt CreatetPicture.mDC, 0, 0, CreatetPicture.Width, CreatetPicture.Height, CreatetPicture.PDC, 0, 0, vbSrcCopy -' - -SetBkColor CreatetPicture.PDC, vbWhite -SetTextColor CreatetPicture.PDC, vbBlack -BitBlt CreatetPicture.PDC, 0, 0, CreatetPicture.Width, CreatetPicture.Height, CreatetPicture.mDC, 0, 0, &H220326 - -'BitBlt Form1.hdc, 100, 100, CreatetPicture.Width, CreatetPicture.Height, CreatetPicture.mDC, 0, 0, vbSrcCopy -End Function - -Public Sub DrawtPicture(tPic As tPicture, ToDC As Long, x As Long, y As Long, Optional Width As Long = -1, Optional Height As Long = -1, Optional SrcX As Long, Optional SrcY As Long) -Dim cBk As Long, cText As Long -If Width = -1 Then Width = tPic.Width -If Height = -1 Then Height = tPic.Height - -If tPic.mDC = 0 Then - BitBlt ToDC, x, y, Width, Height, tPic.PDC, SrcX, SrcY, vbSrcCopy -Else - cBk = GetBkColor(ToDC) - cText = GetTextColor(ToDC) - - SetTextColor ToDC, 0 'RGB(100, 100, 100) - SetBkColor ToDC, vbWhite - - BitBlt ToDC, x, y, Width, Height, tPic.mDC, SrcX, SrcY, vbSrcAnd - BitBlt ToDC, x, y, Width, Height, tPic.PDC, SrcX, SrcY, vbSrcPaint - - SetBkColor ToDC, cBk - SetTextColor ToDC, cText -End If -End Sub - - -Public Sub DeletetPicture(Pic As tPicture) -DeleteObject SelectObject(Pic.mDC, Pic.OldmBitmap) -'DeleteObject Pic.OldmBitmap -DeleteObject Pic.mBitmap -DeleteDC Pic.mDC - -DeleteObject SelectObject(Pic.PDC, Pic.OldpBitmap) -'DeleteObject Pic.OldpBitmap -DeleteObject Pic.pBitmap -DeleteDC Pic.PDC - -Pic.mDC = 0 -Pic.PDC = 0 -Pic.OldmBitmap = 0 -Pic.OldpBitmap = 0 -Pic.mBitmap = 0 -Pic.pBitmap = 0 -Pic.pBitmapBits = 0 -Pic.Height = 0 -Pic.Width = 0 -End Sub - -Public Function GetSubFolderFilesCount(ByVal folder As String) As Long -Dim i As Long, ArrayF() As String, ArrayC As Long, S2 As String, cDir As Long, cSize As Long, S As String -ReDim ArrayF(1 To 1) As String -ArrayC = 1: cDir = 1 -ArrayF(ArrayC) = DirFilterIN(folder) + "\" - -GETFOLDERS: -folder = DirFilterIN(folder) + "\" -S = Dir(folder, vbDirectory Or vbArchive Or vbHidden Or vbNormal Or vbReadOnly Or vbSystem) -Do Until S = "" - If Not StrComp(S, ".") = 0 And Not StrComp(S, "..") = 0 Then - S2 = folder + S - If (GetAttr(S2) And vbDirectory) = vbDirectory Then - ArrayC = ArrayC + 1 - ReDim Preserve ArrayF(1 To ArrayC) As String - ArrayF(ArrayC) = S2 - Else - GetSubFolderFilesCount = GetSubFolderFilesCount + 1 - End If - End If - S = Dir -Loop - -If cDir < ArrayC Then - cDir = cDir + 1 - folder = ArrayF(cDir) - GoTo GETFOLDERS -End If -End Function - -Public Function GetSubFolderFiles(ByVal folder As String, FilesArray() As String) As Long -On Error Resume Next -Dim i As Long, ArrayF() As String, ArrayC As Long, S2 As String, cDir As Long, cSize As Long, S As String -ReDim ArrayF(1 To 1) As String -ArrayC = 1: cDir = 1 -ArrayF(ArrayC) = DirFilterIN(folder) + "\" - -GETFOLDERS: -folder = DirFilterIN(folder) + "\" -S = Dir(folder, vbDirectory Or vbArchive Or vbHidden Or vbNormal Or vbReadOnly Or vbSystem) -Do Until S = "" - If Not StrComp(S, ".") = 0 And Not StrComp(S, "..") = 0 Then - S2 = folder + S - If (GetAttr(S2) And vbDirectory) = vbDirectory Then - ArrayC = ArrayC + 1 - ReDim Preserve ArrayF(1 To ArrayC) As String - ArrayF(ArrayC) = S2 - Else - GetSubFolderFiles = GetSubFolderFiles + 1 - ReDim Preserve FilesArray(1 To GetSubFolderFiles) As String - FilesArray(GetSubFolderFiles) = S2 - End If - End If - S = Dir -Loop - -If cDir < ArrayC Then - cDir = cDir + 1 - folder = ArrayF(cDir) - GoTo GETFOLDERS -End If -End Function - -Public Function GetFolderFiles(ByVal folder As String, FilesArray() As String) As Long -On Error Resume Next -Dim i As Long, S2 As String, cDir As Long, cSize As Long, S As String -cDir = 1 - -GETFOLDERS: -folder = DirFilterIN(folder) + "\" -S = Dir(folder, vbDirectory Or vbArchive Or vbHidden Or vbNormal Or vbReadOnly Or vbSystem) -Do Until S = "" - If Not StrComp(S, ".") = 0 And Not StrComp(S, "..") = 0 Then - S2 = folder + S - If (GetAttr(S2) And vbDirectory) = vbDirectory Then - Else - GetFolderFiles = GetFolderFiles + 1 - ReDim Preserve FilesArray(1 To GetFolderFiles) As String - FilesArray(GetFolderFiles) = S2 - End If - End If - S = Dir -Loop -End Function - -Public Function GetSubFolderSize(ByVal folder As String) As Long -Dim i As Long, ArrayF() As String, ArrayC As Long, S2 As String, cDir As Long, cSize As Long, S As String -ReDim ArrayF(1 To 1) As String -ArrayC = 1: cDir = 1 -ArrayF(ArrayC) = DirFilterIN(folder) + "\" - -GETFOLDERS: -folder = DirFilterIN(folder) + "\" -S = Dir(folder, vbDirectory Or vbArchive Or vbHidden Or vbNormal Or vbReadOnly Or vbSystem) -Do Until S = "" - If Not StrComp(S, ".") = 0 And Not StrComp(S, "..") = 0 Then - S2 = folder + S - If (GetAttr(S2) And vbDirectory) = vbDirectory Then - ArrayC = ArrayC + 1 - ReDim Preserve ArrayF(1 To ArrayC) As String - ArrayF(ArrayC) = S2 - Else - cSize = cSize + FileLen(S2) - End If - End If - S = Dir -Loop - -If cDir < ArrayC Then - cDir = cDir + 1 - folder = ArrayF(cDir) - GoTo GETFOLDERS -End If -GetSubFolderSize = cSize -End Function - -Public Sub CoolBorderPB(PB As PictureBox) -Dim Light As Long, Shadow As Long -Light = &H80000014 -Shadow = &H80000010 - -PB.Line (0, 0)-(PB.ScaleWidth - 1, 0), Shadow -PB.Line (0, 1)-(PB.ScaleWidth - 1, 1), Light - -PB.Line (0, PB.ScaleHeight - 2)-(PB.ScaleWidth - 1, PB.ScaleHeight - 2), Shadow -PB.Line (0, PB.ScaleHeight - 1)-(PB.ScaleWidth - 1, PB.ScaleHeight - 1), Light - -PB.Line (1, 3)-(1, PB.ScaleHeight - 4), Light -PB.Line (2, 3)-(2, PB.ScaleHeight - 4), Shadow -PB.Line (3, 3)-(3, PB.ScaleHeight - 4), Light -PB.Line (4, 3)-(4, PB.ScaleHeight - 4), Shadow -End Sub - -Public Sub StringToArr(Arr() As Byte, S As String) -Dim L As Long -L = Len(S) -ReDim Arr(0 To L) As Byte -CopyMemory Arr(0), ByVal S, L + 1 -End Sub - -Public Function ArrToString(Arr() As Byte, Optional NullEnd As Byte) As String -Dim L As Long -L = UBound(Arr) -ArrToString = String(L, " ") -CopyMemory ByVal ArrToString, Arr(0), L -If Not NullEnd = 0 Then - L = InStr(1, ArrToString, Chr$(0), vbBinaryCompare) - If L = 0 Then Exit Function - ArrToString = Mid$(ArrToString, 1, L - 1) -End If -End Function - -Public Sub SetObjectAddr(ByRef Obj As Object, nObj As Long) -CopyMemory Obj, nObj, 4 -End Sub - -Public Function GetObjectAddr(Obj As Object) As Long -Dim L As Long -CopyMemory L, Obj, 4 -GetObjectAddr = L -End Function - -Public Sub UCaseFirst(S As String) -On Error Resume Next -Mid$(S, 1, 1) = UCase(Mid$(S, 1, 1)) -End Sub - -Public Sub PrintMultiLineW(PB As Object, S As String, W As Long) -On Error Resume Next -Dim ST As String, A As Long, i As Long, x As Long -x = PB.CurrentX -i = 1 -A = InStr(i, S, vbCrLf) -Do Until A = 0 - ST = "" - ST = Mid$(S, i, A - i) - PB.CurrentX = x - - - If PB.TextWidth(ST) > W And W > 0 Then -REB: - If Len(ST) > 1 Then ST = Mid$(ST, 1, Len(ST) - 1) Else ST = "" - If Len(S) = 0 Then GoTo PRNT - If PB.TextWidth(ST + "...") > W Then GoTo REB - ST = ST + "..." - End If -PRNT: - PB.Print ST - - i = A + 2 - A = InStr(i, S, vbCrLf) -Loop - -ST = "" -ST = Mid$(S, i) -PB.CurrentX = x - -If PB.TextWidth(ST) > W And W > 0 Then -REB2: - If Len(ST) > 1 Then ST = Mid$(ST, 1, Len(ST) - 1) Else ST = "" - If Len(S) = 0 Then GoTo PRNT2 - If PB.TextWidth(ST + "...") > W Then GoTo REB2 - ST = ST + "..." -End If -PRNT2: - -PB.Print ST -End Sub - -Public Sub PrintMultiLine(PB As Object, S As String) -On Error Resume Next -Dim ST As String, A As Long, i As Long, x As Long -x = PB.CurrentX -i = 1 -A = InStr(i, S, vbCrLf) -Do Until A = 0 - ST = "" - ST = Mid$(S, i, A - i) - PB.CurrentX = x - PB.Print ST - - i = A + 2 - A = InStr(i, S, vbCrLf) -Loop - -ST = "" -ST = Mid$(S, i) -PB.CurrentX = x -PB.Print ST -End Sub - -Public Sub SaveWindowXY(frm As Form, vName As String) -SaveSetting App.EXEName, vName, "X", frm.Left -SaveSetting App.EXEName, vName, "Y", frm.Top -'SaveSetting "mpTRIAMP", vName, "X", frm.Left -'SaveSetting "mpTRIAMP", vName, "Y", frm.Top -End Sub - -Public Sub LoadWindowXY(frm As Form, vName As String) -frm.Left = GetSetting(App.EXEName, vName, "X", frm.Left) -frm.Top = GetSetting(App.EXEName, vName, "Y", frm.Top) -End Sub - -Public Function SeekZ(vbFile As Long, Optional NewPos As Long = -1) As Long -If NewPos = -1 Then SeekZ = Seek(vbFile) - 1 Else Seek vbFile, NewPos + 1 -End Function - -Public Sub FileCpy(vbFileSource As Long, vbFileDest As Long, Optional BufSize As Long = 32767, Optional List As ListBox, Optional FMTSTR As String, Optional DelayInt As Long) -On Error Resume Next -Dim buf() As Byte, NM As Long, lf As Long -ReDim buf(1 To BufSize) As Byte -lf = LOF(vbFileSource) -Do - If Seek(vbFileSource) + BufSize <= lf Then - Get vbFileSource, , buf() - Put vbFileDest, , buf() - If DelayInt > 0 Then - If FillGet(DelayInt) = 1 Then - List.List(1) = Replace$(FMTSTR, "%", Format$(GetPercent(1, lf, Seek(vbFileSource)), "0") + "%") - List.Refresh - End If - End If - Else - NM = LOF(vbFileSource) - Seek(vbFileSource) + 1 - If NM = 0 Then Exit Do - ReDim buf(1 To NM) As Byte - Get vbFileSource, , buf() - Put vbFileDest, , buf() - Exit Do - End If -Loop -If DelayInt > 0 Then - List.List(1) = Replace$(FMTSTR, "%", "100%") - List.Refresh -End If -End Sub - -Public Function eUBound(ms) As Long -On Error Resume Next -eUBound = UBound(ms) -If eUBound < 0 Then eUBound = 0 -End Function - -Public Function MountDrive(DriveLetter As String, FolderPath As String, Optional Label As String) As Boolean -MountDrive = DefineDosDevice(0, DriveLetter & ":", FolderPath) -If Not Len(Label) = 0 Then SetVolumeLabel DriveLetter & ":\", Label -End Function - -Public Function UnMountDrive(DriveLetter As String) As Boolean -UnMountDrive = DefineDosDevice(DDD_REMOVE_DEFINITION, DriveLetter & ":", "") -End Function - -Public Function GetByteArrayPointer(Arr() As Byte) As Long -Dim u As Long, U2 As Long, U3 As Long, tSA As SAFEARRAY1D - -u = VarPtrArray(Arr()) -U2 = VarPtr(tSA) -CopyMemory U3, ByVal u, 4 -CopyMemory ByVal U2, ByVal U3, Len(tSA) - -GetByteArrayPointer = tSA.pvData -End Function - -Public Function CPP(Text As String, Optional NONT As Boolean) As String -CPP = CPPFormat(Text, NONT) -End Function - -Public Function CPPFormat(ByVal Text As String, Optional NONT As Boolean) As String -If Not NONT Then Text = Replace$(Text, "\n", vbCrLf, , , vbTextCompare) -If Not NONT Then Text = Replace$(Text, "\t", Chr$(9), , , vbTextCompare) -Text = Replace$(Text, "\042", Chr$(34), , , vbTextCompare) -Text = Replace$(Text, "\000", Chr$(0), , , vbTextCompare) -Text = Replace$(Text, "''", Chr$(34), , , vbTextCompare) -Text = Replace$(Text, "\\", "\", , , vbTextCompare) -CPPFormat = Text -End Function - -Public Sub PrintTextCentered(Obj As Object, Text As String) -Obj.CurrentX = (Obj.ScaleWidth / 2) - (Obj.TextWidth(Text) / 2) -'Obj.Print Text -TextOut Obj.hdc, Obj.CurrentX, Obj.CurrentY, Text, Len(Text) -End Sub - -Public Sub PrintTextFullCentered(Obj As Object, Text As String) -Obj.CurrentX = (Obj.ScaleWidth / 2) - (Obj.TextWidth(Text) / 2) -Obj.CurrentY = (Obj.ScaleHeight / 2) - (Obj.TextHeight(Text) / 2) -'Obj.Print Text -TextOut Obj.hdc, Obj.CurrentX, Obj.CurrentY, Text, Len(Text) -End Sub - -Public Function IsMouseInWindow(hWnd As Long, Optional x As Long, Optional y As Long) As Boolean -Dim r As RECT, P As POINTAPI - -GetWindowRect hWnd, r -GetCursorPos P -If P.x >= r.Left And P.x <= r.Right And P.y >= r.Top And P.y <= r.Bottom Then - IsMouseInWindow = True - x = P.x - r.Left - y = P.y - r.Top -Else - IsMouseInWindow = False -End If -End Function - -Public Function IsMouseInControl(xform As Form, xctrl As Control, Optional x As Long, Optional y As Long) As Boolean -Dim r As RECT, P As POINTAPI - -r.Top = (xform.Top / 15 + xctrl.Top) -r.Bottom = (xform.Top / 15 + (xctrl.Top + xctrl.Height)) -r.Left = (xform.Left / 15 + xctrl.Left) -r.Right = (xform.Left / 15 + (xctrl.Left + xctrl.Width)) - -GetCursorPos P - -If P.x >= r.Left And P.x <= r.Right And P.y >= r.Top And P.y <= r.Bottom Then - IsMouseInControl = True - x = P.x - r.Left - y = P.y - r.Top -Else - IsMouseInControl = False -End If -End Function - -Function IsWindowOnScreen(inhandle As Long) As Boolean - -Dim r As RECT, P As POINTAPI, handle As Long, nCurrent As Currency, Current As Currency - -GetWindowRect inhandle, r - - - For P.x = r.Left To r.Right Step 15 - For P.y = r.Top To r.Bottom Step 15 - handle = WindowFromPoint(P.x, P.y) - If handle = inhandle Then IsWindowOnScreen = True: Exit Function - Next - Next - - -IsWindowOnScreen = False - -End Function - -Public Function ObjectRef(Obj As Object) As Long -CopyMemory ObjectRef, Obj, 4 -End Function - -Public Sub CopyFileNoCache(SrcFileName As String, DestFileName As String, Optional Block As Long = 22, Optional ProgressB As Object, Optional UpdateInterval As Long = 50, Optional DoEventsHWND As Long) -Dim buffer() As Byte, BufSize As Long, i As Long, IC As Long, FileSrc As Long, FileDest As Long, UsePB As Byte - -If Not GetObjectAddr(ProgressB) = 0 Then UsePB = 1 - -BufSize = 2 ^ Block -mKill DestFileName -IC = FileLen(SrcFileName) -FileSrc = CreateFile(SrcFileName, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING, 0) -FileDest = CreateFile(DestFileName, GENERIC_WRITE, FILE_SHARE_WRITE, 0, CREATE_NEW, FILE_FLAG_NO_BUFFERING, 0) -'FileDest = CreateFile(DestFileName, GENERIC_WRITE, FILE_SHARE_WRITE Or FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0) -If Not UsePB = 0 Then ProgressB.Max = IC - -ReDim buffer(1 To BufSize) As Byte -Do Until i + BufSize >= IC - ReadFile FileSrc, buffer(1), BufSize, 0, 0 - WriteFile FileDest, buffer(1), BufSize, 0, 0 - i = i + BufSize - If Not UsePB = 0 Then If FillGet(UpdateInterval, 21) = 1 Then ProgressB.Value = i: ProgressB.RePaint: If Not DoEventsHWND = 0 Then mDoEvents DoEventsHWND -Loop - -CloseHandle FileSrc -CloseHandle FileDest - -If i = IC Then Exit Sub - -FileSrc = FreeFile -Open SrcFileName For Binary Access Read As FileSrc - FileDest = FreeFile - Open DestFileName For Binary Access Write As FileDest - BufSize = IC - i - ReDim buffer(1 To BufSize) As Byte - Get FileSrc, i, buffer() - Put FileDest, i, buffer() - i = IC - Close FileDest -Close FileSrc -If Not UsePB = 0 Then ProgressB.Value = i: ProgressB.RePaint -End Sub - -Public Function RangeRnd(Range As Double) As Double -RangeRnd = Rnd * (Range * 2) - Range -End Function - -Public Sub PlayAVI(hWnd As Long, FileName As String) -Dim i As Long, RS As String, cb As Long, A$, x As Long, y As Long - -RS = Space$(128) -A$ = GetSHORT(FileName) -i = mciSendString("open AVIvideo!" & A$ & " alias movie parent " & hWnd & " style child", RS, 128, cb) -'i = mciSendString("open AVIvideo!" & A$ & " alias movie parent " & GetDesktopWindow & " style child", RS, 128, cb) -'i = mciSendString("put movie window at " & 0 & " " & 0 & " " & 1024 & " " & 768, 0&, 0&, 0&) -'i = mciSendString("put movie window client at 200 0 0 0", RS, 128, cb) -'If i Then MsgBox "Error! Probably file not found. Modify the code to point to an .AVI file on your system." -i = mciSendString("play movie", RS, 128, cb) -End Sub - -Public Sub StopAVI() -Dim i As Long, RS As String, cb As Long - -RS = Space$(128) -i = mciSendString("stop movie", RS, 128, cb) -i = mciSendString("close movie", RS, 128, cb) -End Sub - -Public Sub RePlayAVI() -Dim i As Long, RS As String, cb As Long - -RS = Space$(128) -i = mciSendString("play movie from 0", RS, 128, cb) -End Sub - -Public Function GetPosAVI() As Single -Dim i As Long, RS As String, cb As Long, S As Single, S2 As Single - -RS = Space$(128) -i = mciSendString("status movie length", RS, 128, cb) - -If Val(RS) Then - S = Val(RS) - i = mciSendString("status movie position", RS, 128, cb) - GetPosAVI = (Val(RS) / S) * 100 -Else - GetPosAVI = 100 -End If -End Function - -'Public Function AlphaBlend(ByVal destHDC As Long, ByVal XDest As Long, ByVal YDest As Long, ByVal destWidth As Long, ByVal destHeight As Long, ByVal srcHDC As Long, ByVal XSrc As Long, ByVal YSrc As Long, ByVal srcWidth As Long, ByVal srcHeight As Long, ByVal AlphaSource As Long) As Long -' Dim lngBlend As Long -' lngBlend = Val("&h" & Hex(AlphaSource) & "00" & "00") -' AlphaBlending destHDC, XDest, YDest, destWidth, destHeight, srcHDC, XSrc, ycrc, srcWidth, srcHeight, lngBlend -'End Function - -Public Sub SmoothUnload(hWnd As Long) -Dim BG As tPicture, FR As tPicture, BFR As tPicture, r As RECT, DC As Long, i As Long - -GetWindowRect hWnd, r -r.Bottom = r.Bottom - r.Top -r.Right = r.Right - r.Left - -BG = CreateEmptytPicture(r.Right, r.Bottom) -FR = CreateEmptytPicture(r.Right, r.Bottom) -BFR = CreateEmptytPicture(r.Right, r.Bottom) - -DC = GetWindowDC(GetDesktopWindow) -BitBlt FR.PDC, 0, 0, r.Right, r.Bottom, DC, r.Left, r.Top, vbSrcCopy - -ShowWindow hWnd, 0 -DoEvents -Sleep 100 -BitBlt BG.PDC, 0, 0, r.Right, r.Bottom, DC, r.Left, r.Top, vbSrcCopy -ShowWindow hWnd, 4 - -'DC = GetWindowDC(hwnd) -DC = GetWindowDC(GetDesktopWindow) - -For i = 0 To 255 Step 50 - BeginMeter - BitBlt BFR.PDC, 0, 0, r.Right, r.Bottom, BG.PDC, 0, 0, vbSrcCopy - 'AlphaBlend BFR.PDC, 0, 0, R.Right, R.Bottom, FR.PDC, 0, 0, R.Right, R.Bottom, i - BitBlt DC, r.Left, r.Top, r.Right, r.Bottom, BFR.PDC, 0, 0, vbSrcCopy - NeedSleep 20 -Next - -For i = 255 To 0 Step -8 - BeginMeter - BitBlt BFR.PDC, 0, 0, r.Right, r.Bottom, BG.PDC, 0, 0, vbSrcCopy - 'AlphaBlend BFR.PDC, 0, 0, R.Right, R.Bottom, FR.PDC, 0, 0, R.Right, R.Bottom, i - BitBlt DC, r.Left, r.Top, r.Right, r.Bottom, BFR.PDC, 0, 0, vbSrcCopy - NeedSleep 20 -Next - -ShowWindow hWnd, 0 - -DeletetPicture BFR -DeletetPicture FR -DeletetPicture BG -End Sub - -Public Function FilterCommandFN(CFN As String) As String -If Len(CFN) > 0 Then - If Mid$(CFN, 1, 1) = Chr$(34) Then - FilterCommandFN = Mid$(CFN, 2, Len(CFN) - 2) - Else - FilterCommandFN = GetLONGN(CFN) - End If -End If -End Function - -Public Function WindowText(hWnd As Long) As String -Dim L As Long -L = SendMessage(hWnd, WM_GETTEXTLENGTH, 0, CLng(0)) -If L <= 0 Then Exit Function - -WindowText = String(L + 1, " ") -SendMessage hWnd, WM_GETTEXT, L + 1, ByVal WindowText -WindowText = NoZeroS(WindowText) -End Function - -Public Function GetWText(PB As Object, W As Long, Text As String) As String -On Error Resume Next -Dim i As Long, IC As Long -If PB.TextWidth(Text) <= W Then GetWText = Text: Exit Function - -IC = Len(Text) -For i = 1 To IC - If PB.TextWidth(Mid$(Text, 1, i) + "...") > W Then - GetWText = Mid$(Text, 1, i - 1) + "..." - Exit Function - End If -Next -End Function - -Public Function Format3(Value) As String -If Not Value = 0 Then - Format3 = Format$(Value, "#,##0") -Else - Format3 = Format$(Value) -End If -End Function - -Public Function PrintF(ByVal S As String, ParamArray params() As Variant) As String -On Error Resume Next -Dim i As Long, IC As Long, A As Long, B As Long, c As Long, SS As String -Dim S1 As String, S2 As String - -S = CPPFormat(S) -IC = UBound(params) -For i = 0 To IC - If VarType(params(i)) = vbString Then SS = params(i) Else SS = Format$(params(i)) - A = InStr(1, S, "%s", vbTextCompare) - - If A > 1 Then S1 = Mid$(S, 1, A - 1) Else S1 = "" - If Not A = Len(S) - 1 Then S2 = Mid$(S, A + 2) Else S2 = "" - - S = S1 + SS + S2 - 'S = Replace$(S, "%s", SS, A, 2, vbTextCompare) -Next -PrintF = S -End Function - -Public Sub SetChildsEnabled(hWnd As Long, Enable As Long) -Dim A As Long - -A = GetWindow(hWnd, GW_CHILD) -If A = 0 Then Exit Sub -A = GetWindow(A, GW_HWNDFIRST) -If A = 0 Then Exit Sub - -Do - SetChildsEnabled A, Enable - EnableWindow A, Enable - A = GetWindow(A, GW_HWNDNEXT) -Loop Until A = 0 -End Sub - -Public Function GetEnv(VarName As String) As String -GetEnv = String(4096, " ") -GetEnvironmentVariable VarName, GetEnv, 4095 -VarName = NoZeroS(VarName) -End Function - -Public Sub BlendXPIn(frm As Object, Optional Delay As Long = 1000, Optional pv As Long = 2) -On Error Resume Next -Dim h As Long, i As Long -h = GetWindowLong(frm.hWnd, GWL_EXSTYLE) -SetWindowLong frm.hWnd, GWL_EXSTYLE, h Or 524288 - -BeginMeter -Do Until EndMeter > Delay - i = EndMeter / (Delay / CSng(255)) - SetLayeredWindowAttributes frm.hWnd, 0, CByte(i), pv - If i = 0 Then frm.Show - RedrawWindow frm.hWnd, 0, 0, RDW_ERASE Or RDW_INVALIDATE Or RDW_FRAME Or RDW_ALLCHILDREN - DoEvents -Loop - -SetWindowLong frm.hWnd, GWL_EXSTYLE, h -RedrawWindow frm.hWnd, 0, 0, RDW_ERASE Or RDW_INVALIDATE Or RDW_FRAME Or RDW_ALLCHILDREN -End Sub - -Public Sub SetFormLayered(ByRef frm As Object) -On Error Resume Next -Dim h As Long -h = GetWindowLong(frm.hWnd, GWL_EXSTYLE) -SetWindowLong frm.hWnd, GWL_EXSTYLE, h Or 524288 -End Sub - -Public Sub SetFormTColorXP(frm As Object, TColor As Long, Optional Transparency As Long = 255) -On Error Resume Next -Dim h As Long -h = GetWindowLong(frm.hWnd, GWL_EXSTYLE) -SetWindowLong frm.hWnd, GWL_EXSTYLE, h Or 524288 - -SetLayeredWindowAttributes frm.hWnd, TColor, Transparency, IIf(Transparency = 255, 1, 3) -RedrawWindow frm.hWnd, 0, 0, RDW_ERASE Or RDW_INVALIDATE Or RDW_FRAME Or RDW_ALLCHILDREN -End Sub - -Public Sub SetWindowTColorXP(frmHandle As Long, TColor As Long, Optional Transparency As Long = 255) -On Error Resume Next -Dim h As Long -h = GetWindowLong(frmHandle, GWL_EXSTYLE) -SetWindowLong frmHandle, GWL_EXSTYLE, h Or 524288 - -SetLayeredWindowAttributes frmHandle, TColor, Transparency, IIf(Transparency = 255, 1, 3) -RedrawWindow frmHandle, 0, 0, RDW_ERASE Or RDW_INVALIDATE Or RDW_FRAME Or RDW_ALLCHILDREN -End Sub - -Public Sub SetFormAlphaXP(frm As Object, Optional Transparency As Long = 255) -On Error Resume Next -Dim h As Long -h = GetWindowLong(frm.hWnd, GWL_EXSTYLE) -SetWindowLong frm.hWnd, GWL_EXSTYLE, h Or 524288 - -SetLayeredWindowAttributes frm.hWnd, 0, Transparency, 2 -RedrawWindow frm.hWnd, 0, 0, RDW_ERASE Or RDW_INVALIDATE Or RDW_FRAME Or RDW_ALLCHILDREN -End Sub - -Public Sub RemoveFormTColorXP(frm As Object, Optional Transparency As Long = 255) -On Error Resume Next -Dim h As Long -h = GetWindowLong(frm.hWnd, GWL_EXSTYLE) - -If Transparency = 255 Then - SetWindowLong frm.hWnd, GWL_EXSTYLE, IIf(h And 524288, h Xor 524288, h) -Else - SetWindowLong frm.hWnd, GWL_EXSTYLE, h Or 524288 - SetLayeredWindowAttributes frm.hWnd, 0, Transparency, 2 -End If -End Sub - -Public Sub BlendXPOut(frm As Object, Optional Delay As Long = 1000, Optional pv As Long = 2) -On Error Resume Next -Dim h As Long, i As Long -h = GetWindowLong(frm.hWnd, GWL_EXSTYLE) -SetWindowLong frm.hWnd, GWL_EXSTYLE, h Or 524288 - -BeginMeter -Do Until EndMeter > Delay - i = EndMeter / (Delay / CSng(255)) - i = 255 - i - If i < 0 Then i = 0 - SetLayeredWindowAttributes frm.hWnd, 0, CByte(i), pv - RedrawWindow frm.hWnd, 0, 0, RDW_ERASE Or RDW_INVALIDATE Or RDW_FRAME Or RDW_ALLCHILDREN - DoEvents -Loop - -frm.Hide -SetWindowLong frm.hWnd, GWL_EXSTYLE, h -RedrawWindow frm.hWnd, 0, 0, RDW_ERASE Or RDW_INVALIDATE Or RDW_FRAME Or RDW_ALLCHILDREN -End Sub - -Public Function GetParameters(ByVal cLine As String, ParamArr() As String) As Long -Dim i As Long, IC As Long, c As String * 1, InKav As Long - -cLine = Trim$(cLine) -IC = Len(cLine) -If Not IC = 0 Then GetParameters = 1: ReDim ParamArr(1 To GetParameters) As String -For i = 1 To IC - c = Mid$(cLine, i, 1) - If Asc(c) = 32 And InKav = 0 Then - If Not Len(ParamArr(GetParameters)) = 0 Then - GetParameters = GetParameters + 1 - ReDim Preserve ParamArr(1 To GetParameters) As String - End If - ElseIf Asc(c) = 34 Then - InKav = Abs(InKav - 1) - Else - ParamArr(GetParameters) = ParamArr(GetParameters) + c - End If -Next -End Function - -Public Function IsInList(List() As String, Text As String, Optional Compare As VbCompareMethod = vbBinaryCompare) As Long -On Error Resume Next -Dim i As Long, IC As Long, IB As Long -IB = 1 -IC = UBound(List) -IB = LBound(List) -For i = IB To IC - If StrComp(List(i), Text, Compare) = 0 Then - IsInList = i: Exit Function - End If -Next -IsInList = -1 -End Function - -Public Sub AssToMe(Ext As String, Section As String) -FileAss Section, Chr$(34) + DirFilterIN(App.Path) + "\" + App.EXEName + ".exe" + Chr$(34) + " " + Chr$(34) + "%1" + Chr$(34), Ext, DirFilterIN(App.Path) + "\" + App.EXEName + ".exe,0" -End Sub - -Public Function InVB() As Boolean -If InStr(1, App.Path, "vb98", vbTextCompare) = 0 Then InVB = False Else InVB = True -End Function - -Public Function ApplyMenuBitmap(hMenu As Long, Item As Long, PictureHandle As Long) -Dim lngID As Long -lngID = GetMenuItemID(hMenu, Item) -Call ModifyMenu(hMenu, lngID, MF_BITMAP, lngID, PictureHandle) -End Function - - -Public Sub CopyComboBox(Source As Object, dest As Object) -Dim i As Long, IC As Long - -dest.Clear -IC = Source.ListCount - 1 -For i = 0 To IC - dest.AddItem Source.List(i) - dest.ItemData(dest.NewIndex) = Source.ItemData(i) -Next -If Not Source.ListIndex < 0 Then dest.ListIndex = Source.ListIndex -End Sub - -Public Function FindComboBoxItem(Co As ComboBox, Item As String, Optional Compare As VbCompareMethod = vbBinaryCompare) As Long -Dim i As Long, IC As Long - -IC = Co.ListCount - 1 -For i = 0 To IC - If StrComp(Co.List(i), Item, Compare) = 0 Then - FindComboBoxItem = i - Exit Function - End If -Next -FindComboBoxItem = -1 -End Function - -Public Function Is2KXP() As Boolean -Dim B(1 To 4) As Byte -CopyMemory B(1), GetWindowsVersion(), 4 -If B(1) >= 5 Then Is2KXP = True Else Is2KXP = False -End Function - -Public Function Is2K() As Boolean -Dim B(1 To 4) As Byte -CopyMemory B(1), GetWindowsVersion(), 4 -If B(1) = 5 And B(2) = 0 Then Is2K = True -End Function - -Public Function WindowClass(hWnd As Long) As String -WindowClass = String(256, " ") -GetClassName hWnd, ByVal WindowClass, 256 -WindowClass = NoZeroS(WindowClass) -End Function - -Public Function IsTotalCmD(Optional RetPath As String) As Boolean -On Error Resume Next -Dim i, drv As Long, d As String -For i = 0 To 25 - d = Chr$(i + 65) & ":\" - drv = GetDriveType(d) - If drv = DRIVE_FIXED Then - If CheckFile(d & "Totalcmd\TOTALCMD.EXE") = 1 Then RetPath = d & "Totalcmd\TOTALCMD.EXE": IsTotalCmD = True: Exit Function - If CheckFile(d & "Program Files\totalcmd\TOTALCMD.EXE") = 1 Then RetPath = d & "Program Files\totalcmd\TOTALCMD.EXE": IsTotalCmD = True: Exit Function - End If -NoDrive: -Next i -IsTotalCmD = False -End Function - -Public Function OpenInTotalCmD(Path As String) As Long -On Error Resume Next -Dim A As Long, S As String, B As Long -A = GetWindow(GetDesktopWindow, GW_CHILD) -If A = 0 Then GoTo PARTTWO -A = GetWindow(A, GW_HWNDFIRST) - -Do - If InStr(1, WindowText(A), "Total Commander", vbTextCompare) = 1 Then - B = A - ShowWindow A, 1 - SetWindowPos A, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE Or SWP_NOSIZE - A = GetWindow(A, 5) - If A = 0 Then A = B: GoTo NEX - A = GetWindow(A, GW_HWNDFIRST) - Do - If WindowClass(A) = "TMyPanel" Then - A = GetWindow(A, GW_CHILD) - If A = 0 Then A = B: GoTo NEX - A = GetWindow(A, GW_HWNDFIRST) - Do - If WindowClass(A) = "TComboBox" Then - SendMessage A, WM_SETTEXT, 0, ByVal ("cd " & Path) - SendMessage A, WM_KEYDOWN, 13, 0 - SendMessage A, WM_KEYUP, 13, 0 - Exit Function - End If - A = GetWindow(A, GW_HWNDNEXT) - Loop Until A = 0 - End If - A = GetWindow(A, GW_HWNDNEXT) - Loop Until A = 0 - A = B: GoTo NEX - End If -NEX: - A = GetWindow(A, GW_HWNDNEXT) -Loop Until A = 0 - - -PARTTWO: -If IsTotalCmD(S) = True Then - Call Shell(S & " " & Path, vbNormalFocus) -End If -End Function - -Public Function SendTompTRIAMP(Text As String) As Long -On Error Resume Next -Dim A As Long, S As String, B As Long -A = FindWindowS(0, "mpTRIAMP PlayList (Waiting...)") -If A = 0 Then Exit Function - -ShowWindow A, 1 -SetWindowPos A, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE Or SWP_NOSIZE -A = GetWindow(A, 5) -If A = 0 Then Exit Function -SendMessage A, WM_SETTEXT, 0, ByVal Text -SendTompTRIAMP = 1 -End Function - -Public Function UnHex2(S As String) As Byte -Dim B1 As Byte, b2 As Byte, B As Byte - -B = Asc(Mid$(S, 1, 1)) -B1 = IIf(B > 64, B - 55, B - 48) -B = Asc(Mid$(S, 2, 1)) -b2 = IIf(B > 64, B - 55, B - 48) - -UnHex2 = B1 * 16 + b2 -End Function - -Public Function ConvertHexColor(ByVal HexColor As String) As Long -If Not Len(HexColor) = 6 Then Exit Function - -HexColor = UCase$(HexColor) -ConvertHexColor = RGB(UnHex2(Mid$(HexColor, 1, 2)), UnHex2(Mid$(HexColor, 3, 2)), UnHex2(Mid$(HexColor, 5, 2))) -End Function - -Public Function DrawBitmapToDC(hBMP As Long, x As Long, y As Long, W As Long, h As Long, ToDC As Long, SrcX As Long, SrcY As Long, Optional Rop As Long = vbSrcCopy) -Dim hdc As Long, hBmpOld As Long - -hdc = CreateCompatibleDC(0) -hBmpOld = SelectObject(hdc, hBMP) - -BitBlt ToDC, x, y, W, h, hdc, SrcX, SrcY, Rop - -SelectObject hdc, hBmpOld -DeleteDC hdc -End Function - -Public Function FilterFileName(FN As String) As String -FilterFileName = FN -FilterFileName = Replace$(FilterFileName, ";", "_") -FilterFileName = Replace$(FilterFileName, "\", "_") -FilterFileName = Replace$(FilterFileName, "|", "_") -FilterFileName = Replace$(FilterFileName, "/", "_") -FilterFileName = Replace$(FilterFileName, ":", "_") -FilterFileName = Replace$(FilterFileName, "*", "_") -FilterFileName = Replace$(FilterFileName, "<", "_") -FilterFileName = Replace$(FilterFileName, ">", "_") -FilterFileName = Replace$(FilterFileName, "?", "_") -FilterFileName = Replace$(FilterFileName, Chr$(34), "_") -End Function - -Public Function FormatFF(Expression, Optional formats, Optional FirstDayOfWeek As VbDayOfWeek = vbMonday, Optional FirstWeekOfYear As VbFirstWeekOfYear = vbFirstJan1) As String -FormatFF = FixFloatF(Format$(Expression, formats, FirstDayOfWeek, FirstWeekOfYear)) -End Function - -Public Function uBOUNDL(LongArray() As Long) As Long -On Error Resume Next -uBOUNDL = UBound(LongArray()) -End Function - -Public Function uBOUNDB(LongArray() As Byte) As Long -On Error Resume Next -uBOUNDB = UBound(LongArray()) -End Function - -Public Function CompressString(Text As String, Optional level As Long = 9) As String -Dim Arr() As Byte -StringToArray Text, Arr() -CompressArray Arr(), level -ArrayToString CompressString, Arr() -End Function - -Public Function DecompressString(Text As String) As String -Dim Arr() As Byte -StringToArray Text, Arr() -DecompressArray Arr() -ArrayToString DecompressString, Arr() -End Function - -Public Function CompressArray(Arr() As Byte, Optional level As Long = 9) As Long -Dim IB As Long, IC As Long, DestIC As Long -Dim DestArr() As Byte, DL As Long, r As Long - -CompressArray = 4 -IC = uBOUNDB(Arr()) -If IC = -1 Then ReDim Arr(1 To 4) As Byte: CopyMemory Arr(1), CLng(4), 4: Exit Function -IB = LBound(Arr()) -DestIC = IC * 1.5 -ReDim DestArr(IB To DestIC) As Byte - -DL = (DestIC - IB) + 1 -r = compress2(DestArr(IB), DL, Arr(IB), (IC - IB) + 1, level) -If r <> 0 Then Erase Arr(): CompressArray = 0: Exit Function - -ReDim Arr(IB To (DL + IB) + 3) As Byte -CopyMemory Arr(IB), CLng((IC - IB) + 1), 4 -CopyMemory Arr(IB + 4), DestArr(IB), DL -CompressArray = DL + 4 -End Function - -Public Function DecompressArray(Arr() As Byte, Optional ArrlBound As Long = 1) As Long -Dim IB As Long, IC As Long, DestIC As Long -Dim DestArr() As Byte, DL As Long - -IC = -1 -IC = uBOUNDB(Arr()) -IB = ArrlBound -If IC = -1 Then Erase Arr: Exit Function -CopyMemory DL, Arr(IB), 4 -If DL <= 0 Or DL > 100000000 Then Erase Arr: Exit Function - -DestIC = DL -ReDim DestArr(IB To DestIC) As Byte - -'DL = (DestIC - IB) + 1 -If uncompress(DestArr(IB), DL, Arr(IB + 4), (IC - IB) - 3) <> 0 Then Erase Arr(): DecompressArray = 0: Exit Function - -ReDim Arr(IB To (DL + IB) - 1) As Byte -CopyMemory Arr(IB), DestArr(IB), DL -DecompressArray = DL -End Function - -Public Function ByteArrayPointer(Arr() As Byte) As Long -Dim u As Long, U2 As Long, U3 As Long, tSA As SAFEARRAY2D - -u = VarPtrArray(Arr()) -U2 = VarPtr(tSA) -CopyMemory U3, ByVal u, 4 -CopyMemory ByVal U2, ByVal U3, Len(tSA) - -ByteArrayPointer = tSA.pvData -'MsgBox GetUnitDataPointer & vbCrLf & VBArrayPointer(Arr()) -End Function - -Public Function DateTimeFN() As String -DateTimeFN = Format$(Year(Date)) & Format$(Month(Date), "00") & Format$(Day(Date), "00") & Format$(Hour(time), "00") & Format$(Minute(time), "00") & Format$(Second(time), "00") & Format$(SystemTimer, "0000000000") -End Function - -Public Sub AddToString(Text As String, Add As String, Optional Char As String = vbCrLf) -If Len(Text) = 0 Then Text = Add Else Text = Text & Char & Add -End Sub - -Public Function FillGetC(INTERVAL As Long, Optional LastTime As Long = 0) As Byte -If timeGetTime - LastTime >= INTERVAL Then FillGetC = 1: Exit Function -If timeGetTime < LastTime Then FillGetC = 1 'TFill(i) = timeGetTime -End Function - -Public Function IsNT() As Boolean -Dim V As OSVERSIONINFO -V.dwOSVersionInfoSize = Len(V) -If GetVersionEx(V) <> 0 Then - If V.dwPlatformId = 2 Then IsNT = True -End If -End Function - -Public Sub GetVideoMode(ByRef scWidth As Long, ByRef scHeight As Long, ByRef scDepth As Long) - Dim hdc As Long - hdc = GetDC(GetDesktopWindow()) - scWidth = GetDeviceCaps(hdc, HORZRES) - scHeight = GetDeviceCaps(hdc, VERTRES) - scDepth = GetDeviceCaps(hdc, BITSPIXEL) - ReleaseDC GetDesktopWindow(), hdc -End Sub - -Public Function ScreenWidth() As Long -Dim L As Long -GetVideoMode L, 0, 0 -ScreenWidth = L -End Function - -Public Function ScreenHeight() As Long -Dim L As Long -GetVideoMode 0, L, 0 -ScreenHeight = L -End Function - -Public Function ScreenDepth() As Long -Dim L As Long -GetVideoMode 0, 0, L -ScreenDepth = L -End Function - -Public Function MySplit(ToArray() As String, Expression As String, Optional Delimiter As String = vbCrLf, Optional Limit As Long, Optional Compare As VbCompareMethod = vbBinaryCompare) As Long -Dim TAC As Long, i As Long, L As Long -Erase ToArray() - -If Len(Expression) = 0 Then ReDim ToArray(1 To 1) As String: TAC = 1 - -L = 1 -Do - If Compare = vbBinaryCompare Then - i = MyInStr(L, Expression, Delimiter) - Else - i = InStr(L, Expression, Delimiter, Compare) - End If - If i = 0 Then Exit Do - TAC = TAC + 1 - ReDim Preserve ToArray(1 To TAC) As String - ToArray(TAC) = Mid$(Expression, L, (i - L)) - - If TAC >= Limit And Limit > 0 Then ToArray(TAC) = ToArray(TAC) & Mid$(Expression, i): GoTo NEX - L = i + Len(Delimiter) -Loop -If Len(Expression) >= L Then - TAC = TAC + 1 - ReDim Preserve ToArray(1 To TAC) As String - ToArray(TAC) = Mid$(Expression, L) -End If - -NEX: -MySplit = TAC -End Function - -Public Function IsPathRelative(Path As String) As Boolean -If Len(Path) < 3 Then IsPathRelative = True: Exit Function -If Mid$(Path, 1, 2) = "//" Then Exit Function -If Not Mid$(Path, 2, 1) = ":" Then IsPathRelative = True: Exit Function -End Function - -Public Function SortStringArray(Arr() As String, Optional Compare As VbCompareMethod = vbTextCompare) As Long -On Error Resume Next -Dim i As Long, IC As Long, j As Long, k As Long -Dim index As Long, Index2 As Long, M_index As Long, M_index2 As Long -Dim firstItem As Long, distance As Long, Value As String -Dim m_Value As Long, numEls As Long - -IC = UBound(Arr) -If IC = 0 Then Exit Function - -'ShellSort -numEls = IC -firstItem = 1 -Do - distance = distance * 3 + 1 -Loop Until distance > numEls -Do - distance = distance \ 3 - For index = distance + 1 To numEls - Value = Arr(index) - Index2 = index - Do While StrComp(Arr(Index2 - distance), Value, Compare) > 0 - Arr(Index2) = Arr(Index2 - distance) - Index2 = Index2 - distance - If Index2 <= distance Then Exit Do - Loop - Arr(Index2) = Value - Next -Loop Until distance = 1 -SortStringArray = IC -End Function - -Public Function SortStringArrayFN(Arr() As String, Optional Compare As VbCompareMethod = vbTextCompare) As Long -On Error Resume Next -Dim i As Long, IC As Long, j As Long, k As Long -Dim index As Long, Index2 As Long, M_index As Long, M_index2 As Long -Dim firstItem As Long, distance As Long, Value As String -Dim m_Value As Long, numEls As Long - -IC = UBound(Arr) -If IC = 0 Then Exit Function - -'ShellSort -numEls = IC -firstItem = 1 -Do - distance = distance * 3 + 1 -Loop Until distance > numEls -Do - distance = distance \ 3 - For index = distance + 1 To numEls - Value = Arr(index) - Index2 = index - Do While StrComp(GetFileNameIN(Arr(Index2 - distance)), GetFileNameIN(Value), Compare) > 0 - Arr(Index2) = Arr(Index2 - distance) - Index2 = Index2 - distance - If Index2 <= distance Then Exit Do - Loop - Arr(Index2) = Value - Next -Loop Until distance = 1 -SortStringArrayFN = IC -End Function - -Public Function LoadIcon32(FN As String) As Sprite32 -On Error Resume Next -Dim f As Long -Dim id As ICONDIR, IDE As ICONDIRENTRY -Dim bih As BITMAPINFOHEADER - -f = FreeFile -Open FN For Binary Access Read As #f -If f = FreeFile Then Exit Function - Get #f, 1, id - Get #f, , IDE - Get #f, , bih - LoadIcon32.Width = bih.biWidth - LoadIcon32.Height = bih.biHeight / 2 - ReDim LoadIcon32.bits(1 To LoadIcon32.Width, 1 To LoadIcon32.Height) As BGRT - Get #f, , LoadIcon32.bits() -Close f -End Function - -Public Function LoadTGA32(FN As String, Optional ByVal Pos As Long = 1) As Sprite32 -On Error Resume Next -Dim f As Long, W As Integer, h As Integer, T As Long, B As Byte - -f = FreeFile -Open FN For Binary Access Read As #f -If f = FreeFile Then Exit Function - Get #f, Pos, T - If Not T = 131072 Then Exit Function 'Not TGA - Get #f, Pos + 12, W - Get #f, Pos + 14, h - Get #f, Pos + 16, B - If Not B = 32 Then Exit Function 'Not 32 Bit - - LoadTGA32.Width = W - LoadTGA32.Height = h - ReDim LoadTGA32.bits(1 To LoadTGA32.Width, 1 To LoadTGA32.Height) As BGRT - Get #f, Pos + 18, LoadTGA32.bits() -Close f -End Function - -Public Function GetBGRTPointer(Arr() As BGRT) As Long -Dim u As Long, U2 As Long, U3 As Long, tSA As SAFEARRAY1D - -u = VarPtrArray(Arr()) -U2 = VarPtr(tSA) -CopyMemory U3, ByVal u, 4 -CopyMemory ByVal U2, ByVal U3, Len(tSA) - -GetBGRTPointer = tSA.pvData -End Function - -Public Function LoadTGA32Mem(Data() As Byte) As Sprite32 -On Error Resume Next -Dim f As Long, W As Integer, h As Integer, T As Long, B As Byte ', i As Long, j As Long, L As Long -'Dim MS() As BGRT -'Dim BT() As BGRT - -CopyMemory T, Data(1), 4 -If Not T = 131072 Then Exit Function 'Not TGA -CopyMemory W, Data(13), 2 -CopyMemory h, Data(15), 2 -CopyMemory B, Data(17), 1 -If Not B = 32 Then Exit Function 'Not 32 Bit - -LoadTGA32Mem.Width = W -LoadTGA32Mem.Height = h -ReDim LoadTGA32Mem.bits(1 To LoadTGA32Mem.Width, 1 To LoadTGA32Mem.Height) As BGRT -'ReDim MS(1 To LoadTGA32Mem.Width, 1 To LoadTGA32Mem.Height) As BGRT -'ReDim BT(1 To LoadTGA32Mem.Width, 1 To LoadTGA32Mem.Height) As BGRT -'For i = 1 To W -' For j = 1 To H -' LoadTGA32Mem.Bits(i, j).B = Data(19 + L): L = L + 1 -' LoadTGA32Mem.Bits(i, j).G = Data(19 + L): L = L + 1 -' LoadTGA32Mem.Bits(i, j).R = Data(19 + L): L = L + 1 -' LoadTGA32Mem.Bits(i, j).T = Data(19 + L): L = L + 1 -' Next -'Next - -'MsgBox VarPtr(MS(1, 1)) & " - " & GetBGRTPointer(MS()) - -CopyMemory ByVal GetBGRTPointer(LoadTGA32Mem.bits()), Data(19), CLng(W) * CLng(h) * 4# -'MsgBox Data(19) & " - " & MS(1, 1).B & " - " & CLng(W) * CLng(H) * 4# -'LoadTGA32Mem.Bits = MS -End Function - -Public Function CreateSprite32(ByVal Width As Long, ByVal Height As Long) As Sprite32 -CreateSprite32.Width = Width -CreateSprite32.Height = Height -ReDim CreateSprite32.bits(1 To Width, 1 To Height) As BGRT -End Function - -Public Function InvertAlpha32(SPR As Sprite32, Optional ByVal x As Long, Optional ByVal y As Long, Optional ByVal W As Long = -1, Optional ByVal h As Long = -1) As Long -If W < 0 Then W = SPR.Width -If h < 0 Then h = SPR.Height -InvertAlpha32C SPR, x, y, W, h -End Function - -Public Function LoadRes(id As Long, ms() As Byte) As Long -On Error Resume Next -Dim Arr() As Byte, IC As Long -Arr = LoadResData(id, "Custom") -IC = UBound(Arr) + 1 -ReDim ms(1 To IC) As Byte -CopyMemory ms(1), Arr(0), IC -LoadRes = IC -End Function - -Public Function LoadResS(id As Long) As String -On Error Resume Next -Dim Arr() As Byte, IC As Long -Arr = LoadResData(id, "Custom") -IC = UBound(Arr) + 1 -LoadResS = String(IC, " ") -CopyMemory ByVal LoadResS, Arr(0), IC -End Function - -Public Function MenuResHandle(id As Long) As Long -Dim ms() As Byte -LoadRes id, ms(): MenuResHandle = GetIcon32Handle(LoadTGA32Mem(ms())) -End Function - -Public Function ResIcon32(id As Long) As Sprite32 -Dim ms() As Byte -LoadRes id, ms() -ResIcon32 = LoadIcon32Mem(ms()) -End Function - -Public Function LoadIcon32Mem(Data() As Byte) As Sprite32 -On Error Resume Next -Dim f As Long -Dim id As ICONDIR, IDE As ICONDIRENTRY -Dim bih As BITMAPINFOHEADER - -f = FreeFile -'Open FN For Binary Access Read As #F -'If F = FreeFile Then Exit Function - 'Get #F, 1, id - 'Get #F, , IDE - 'Get #F, , bih - CopyMemory id, Data(1), Len(id) - CopyMemory IDE, Data(1 + Len(id)), Len(IDE) - CopyMemory bih, Data(1 + Len(id) + Len(IDE)), Len(bih) - LoadIcon32Mem.Width = bih.biWidth - LoadIcon32Mem.Height = bih.biHeight / 2 - ReDim LoadIcon32Mem.bits(1 To LoadIcon32Mem.Width, 1 To LoadIcon32Mem.Height) As BGRT - 'Get #F, , LoadIcon32Mem.Bits() - CopyMemory LoadIcon32Mem.bits(1, 1), Data(1 + Len(id) + Len(IDE) + Len(bih)), LoadIcon32Mem.Width * LoadIcon32Mem.Height * 4 -'Close F -End Function - -Public Function GetIcon32Handle(SPR As Sprite32) As Long -On Error Resume Next -Dim i As Long, L As Long -i = 1 -Do - If FindIcon32Handle(i) = 0 Then Exit Do - i = i + 1 -Loop - -L = UBound(IconHandles) -L = L + 1 -ReDim Preserve IconHandles(1 To L) As IconsHandles -IconHandles(L).handle = i -IconHandles(L).Icon = SPR -GetIcon32Handle = i -End Function - -Public Function FindIcon32Handle(handle As Long) As Long -On Error Resume Next -Dim i As Long, IC As Long - -IC = UBound(IconHandles) -For i = 1 To IC - If IconHandles(i).handle = handle Then FindIcon32Handle = i: Exit Function -Next -End Function - -Public Function DrawSprite32(SPR As Sprite32, hdc As Long, Optional x As Long, Optional y As Long) As Long -Dim tDC As Long, tBitmap As Long, tBO As Long, BitsPtr As Long, SA As SAFEARRAY2D -Dim SPR24 As Sprite24 - -tDC = CreateCompatibleDC(0) -tBitmap = CreateDIB(tDC, SPR.Width, SPR.Height, BitsPtr, 24) -tBO = SelectObject(tDC, tBitmap) -BitBlt tDC, 0, 0, SPR.Width, SPR.Height, hdc, x, y, vbSrcCopy - -'ReDim SPR24.Bits(1 To RGBWidth(SPR.Width), 1 To SPR.Height) As Byte -SPR24.Width = SPR.Width -SPR24.Height = SPR.Height - -With SA - .cbElements = 1 - .cDims = 2 - .Bounds(0).lLbound = 1 - .Bounds(0).cElements = SPR.Height - .Bounds(1).lLbound = 1 - .Bounds(1).cElements = RGBWidth(SPR.Width) - .pvData = BitsPtr -End With - -CopyMemory ByVal VarPtrArray(SPR24.bits()), VarPtr(SA), 4 -BitBlt32to24C SPR24, 0, 0, SPR.Width, SPR.Height, SPR, 0, 0 -BitBlt hdc, x, y, SPR.Width, SPR.Height, tDC, 0, 0, vbSrcCopy - - -CopyMemory ByVal VarPtrArray(SPR24.bits()), CLng(0), 4 -DeleteObject SelectObject(tDC, tBO) -DeleteObject tBitmap -DeleteDC tDC -End Function - -Public Function DrawSprite24(SPR As Sprite24, hdc As Long, Optional x As Long, Optional y As Long) As Long -Dim tDC As Long, tBitmap As Long, tBO As Long, BitsPtr As Long, SA As SAFEARRAY2D -Dim SPR24 As Sprite24 - -tDC = CreateCompatibleDC(0) -tBitmap = CreateDIB(tDC, SPR.Width, SPR.Height, BitsPtr, 24) -tBO = SelectObject(tDC, tBitmap) -BitBlt tDC, 0, 0, SPR.Width, SPR.Height, hdc, x, y, vbSrcCopy - -'ReDim SPR24.Bits(1 To RGBWidth(SPR.Width), 1 To SPR.Height) As Byte -SPR24.Width = SPR.Width -SPR24.Height = SPR.Height - -With SA - .cbElements = 1 - .cDims = 2 - .Bounds(0).lLbound = 1 - .Bounds(0).cElements = SPR.Height - .Bounds(1).lLbound = 1 - .Bounds(1).cElements = RGBWidth(SPR.Width) - .pvData = BitsPtr -End With - -CopyMemory ByVal VarPtrArray(SPR24.bits()), VarPtr(SA), 4 -BitBlt24to24C SPR24, 0, 0, SPR.Width, SPR.Height, SPR, 0, 0 -BitBlt hdc, x, y, SPR.Width, SPR.Height, tDC, 0, 0, vbSrcCopy - - -CopyMemory ByVal VarPtrArray(SPR24.bits()), CLng(0), 4 -DeleteObject SelectObject(tDC, tBO) -DeleteObject tBitmap -DeleteDC tDC -End Function - -Public Sub VertivalFlipSprite24(dest As Sprite24) -Dim W As Long, ms() As Byte, i As Long, IC As Long, MC As Long, k As Long - -W = UBound(dest.bits, 1) -ReDim ms(1 To W) As Byte - -MC = UBound(dest.bits, 2) -IC = (MC \ 2) - 1 -k = W -For i = 0 To IC - CopyMemoryC ms(1), dest.bits(1, i + 1), k - CopyMemoryC dest.bits(1, i + 1), dest.bits(1, MC - i), k - CopyMemoryC dest.bits(1, MC - i), ms(1), k -Next -End Sub - -Public Function Split2(ByVal Text As String, Delimiter As String, Optional S1 As String, Optional S2 As String, Optional Compare As VbCompareMethod = vbBinaryCompare) As Long -Dim i As Long -S1 = "": S2 = "" -i = InStr(1, Text, Delimiter, Compare) -If i = 0 Then S1 = Text: Exit Function -If i = 1 And Len(Delimiter) = Len(Text) Then Exit Function -If i = 1 Then S2 = Mid$(Text, Len(Delimiter) + 1): Exit Function -If i + Len(Delimiter) = Len(Text) + 1 Then S1 = Mid$(Text, 1, i - 1): Exit Function -S1 = Mid$(Text, 1, i - 1): S2 = Mid$(Text, i + Len(Delimiter)) -End Function - -Public Function AddAlpha32(SPR As Sprite32, ByVal Add As Long, Optional ByVal x As Long, Optional ByVal y As Long, Optional ByVal W As Long = -1, Optional ByVal h As Long = -1) As Long -If W = -1 Then W = SPR.Width -If h = -1 Then h = SPR.Height -AlphaAdd32C SPR, x, y, W, h, Add -End Function - -Public Function CreateEmptytPicture32(ByVal Width As Long, ByVal Height As Long, ByVal Ptr As Long, Optional AlwaysMem As Boolean) As tPicture -Dim MaskColor As Long, hPal As Long -Dim cBk As Long, cText As Long -Dim tDC As Long, tBitmap As Long, tBO As Long, BPS As Long - -hDcScreen = CreateCompatibleDC(0) 'GetDC(0&) -hPal = CreateHalftonePalette(hDcScreen) -'OleTranslateColor TColor, hPal, MaskColor - -CreateEmptytPicture32.Width = Width -CreateEmptytPicture32.Height = Height -CreateEmptytPicture32.PDC = CreateCompatibleDC(0) -BPS = GetDeviceCaps(CreateEmptytPicture32.PDC, BITSPIXEL) - -If BPS = 32 And Not AlwaysMem Then - VertivalFlipPtr32 Ptr, Width, Height - CreateEmptytPicture32.pBitmap = CreateBitmap(CreateEmptytPicture32.Width, CreateEmptytPicture32.Height, 1, BPS, ByVal Ptr) - CreateEmptytPicture32.OldpBitmap = SelectObject(CreateEmptytPicture32.PDC, CreateEmptytPicture32.pBitmap) -Else - CreateEmptytPicture32.pBitmap = CreateDIB(CreateEmptytPicture32.PDC, CreateEmptytPicture32.Width, CreateEmptytPicture32.Height, CreateEmptytPicture32.pBitmapBits, 32) - CreateEmptytPicture32.OldpBitmap = SelectObject(CreateEmptytPicture32.PDC, CreateEmptytPicture32.pBitmap) - If Ptr <> 0 Then CopyMemory ByVal CreateEmptytPicture32.pBitmapBits, ByVal Ptr, Width * Height * 4 -End If -End Function - -Public Sub VertivalFlipPtr32(Ptr As Long, W As Long, h As Long) -Dim ms() As Long, i As Long, IC As Long, MC As Long, k As Long - -ReDim ms(1 To W) As Long - -MC = h -IC = (MC \ 2) - 1 -k = W * 4 -For i = 0 To IC - CopyMemoryC ms(1), ByVal (Ptr + i * k), k - CopyMemoryC ByVal (Ptr + i * k), ByVal (Ptr + (MC - (i + 1)) * k), k - CopyMemoryC ByVal (Ptr + (MC - (i + 1)) * k), ms(1), k -Next -End Sub - -Public Sub VertivalFlipSprite32(dest As Sprite32) -Dim W As Long, ms() As Long, i As Long, IC As Long, MC As Long, k As Long - -W = UBound(dest.bits, 1) -ReDim ms(1 To W) As Long - -MC = UBound(dest.bits, 2) -IC = (MC \ 2) - 1 -k = W * 4 -For i = 0 To IC - CopyMemoryC ms(1), dest.bits(1, i + 1), k - CopyMemoryC dest.bits(1, i + 1), dest.bits(1, MC - i), k - CopyMemoryC dest.bits(1, MC - i), ms(1), k -Next -End Sub - -Public Function FillF(Ptr As Long, W As Long, h As Long) As Long -Dim i As Long, IC As Long, j As Long, JC As Long, B As Byte, ms() As Long - -IC = W: JC = h -ReDim ms(1 To IC) As Long -For j = 1 To JC - For i = 1 To IC - 'B = S.Bits(i, j).B - 'S.Bits(i, j).B = S.Bits(i, j).T - 'S.Bits(i, j).T = B - ms(i) = &H2F888888 - Next - 'CopyMemory ByVal (Ptr + (j - 1) * IC * 4), MS(1), IC * 4 -Next -End Function - -Public Function CreatetPicture32FromTGA(FN As String, Optional Pos As Long = 1) As tPicture -Dim S As Sprite32, i As Long, j As Long -S = LoadTGA32(FN, Pos) - -For i = 1 To S.Width - For j = 1 To S.Height - If S.bits(i, j).T < 255 Then - S.bits(i, j).B = (CLng(S.bits(i, j).T) * CLng(S.bits(i, j).B)) \ 255 - S.bits(i, j).g = (CLng(S.bits(i, j).T) * CLng(S.bits(i, j).g)) \ 255 - S.bits(i, j).r = (CLng(S.bits(i, j).T) * CLng(S.bits(i, j).r)) \ 255 - End If - Next -Next - -FillF VarPtr(S.bits(1, 1)), S.Width, S.Height - -CreatetPicture32FromTGA = CreateEmptytPicture32(S.Width, S.Height, VarPtr(S.bits(1, 1))) -'CreatetPicture32FromTGA = CreateEmptytPicture32(320, 240, 0) - -Exit Function - - -Dim tDC As Long, tBitmap As Long, tBO As Long, BitsPtr As Long ', SA As SAFEARRAY2D -'Dim SPR As Sprite32 - -tDC = CreateCompatibleDC(0) -tBitmap = CreateDIB(tDC, S.Width, S.Height, BitsPtr, 32) -tBO = SelectObject(tDC, tBitmap) -'BitBlt tDC, 0, 0, SPR.Width, SPR.Height, hdc, X, Y, vbSrcCopy - -'SPR32.Width = SPR.Width -'SPR32.Height = SPR.Height - -'With SA -' .cbElements = 1 -' .cDims = 2 -' .Bounds(0).lLbound = 1 -' .Bounds(0).cElements = S.Height -' .Bounds(1).lLbound = 1 -' .Bounds(1).cElements = S.Width * 4 -' .pvData = BitsPtr -'End With - -'CopyMemory ByVal VarPtrArray(SPR24.Bits()), VarPtr(SA), 4 -CopyMemory ByVal BitsPtr, S.bits(1, 1), S.Width * S.Height * 4 - -BitBltA CreatetPicture32FromTGA.PDC, x, y, S.Width, S.Height, tDC, 0, 0, S.Width, S.Height, 255 - - -'CopyMemory ByVal VarPtrArray(SPR24.Bits()), CLng(0), 4 -DeleteObject SelectObject(tDC, tBO) -DeleteObject tBitmap -DeleteDC tDC -End Function - -Public Sub ApplytPicture32ToFormXP(tPic As tPicture, ByVal hWnd As Long) -Dim h As Long, BF As blendFunction, P As POINTAPI, p1 As POINTAPI - -P.x = tPic.Width -P.y = tPic.Height - -SetWindowPos hWnd, 0, 0, 0, tPic.Width, tPic.Height, &H10 Or &H2 Or &H200 Or &H4 - -BF.AlphaFormat = 1 -BF.BlendOp = 0 -BF.SourceConstantAlpha = 255 -'Call UpdateLayeredWindow(hwnd, 0, VarPtr(P1), VarPtr(P), tPic.PDC, VarPtr(P1), 0, BF, 2) -Call UpdateLayeredWindow(hWnd, 0, 0, VarPtr(P), tPic.PDC, VarPtr(p1), 0, BF, 2) -RedrawWindow hWnd, 0, 0, RDW_ERASE Or RDW_INVALIDATE Or RDW_FRAME Or RDW_ALLCHILDREN - -End Sub - -Public Function BitBltA(ByVal hDestDC As Long, ByVal x As Long, ByVal y As Long, ByVal nWidthDest As Long, ByVal nHeightDest As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal nWidthSrc As Long, ByVal nHeightSrc As Long, alpha As Byte) As Long -Dim AF As blendFunction, L As Long - -'AC_SRC_OVER=0 -'AC_SRC_ALPHA=1 -AF.AlphaFormat = 1 -AF.SourceConstantAlpha = alpha -AF.BlendOp = 0 -AF.BlendFlags = 0 -CopyMemory L, AF, 4 -Call AlphaBlendA(hDestDC, x, y, nWidthDest, nHeightDest, hSrcDC, xSrc, ySrc, nWidthSrc, nHeightSrc, ByVal L) -End Function - -Public Function GetComment(FN As String) As String -On Error Resume Next -Dim S As String, IC As Long, Arr() As String, i As Long, S2 As String -Dim sFN As String, L As Long - -sFN = GetFileNameIN(FN) -S = LoadFile(GetPathOnlyIN(FN) & "descript.ion") -IC = MySplit(Arr(), S) -For i = 1 To IC - If Len(Trim$(Arr(i))) > 0 Then - If Mid$(Arr(i), 1, 1) = Chr$(34) Then - L = InStr(2, Arr(i), Chr$(34)) - S = "": S2 = "" - If L > 2 Then - S = Mid$(Arr(i), 2, L - 2) - S2 = Mid$(Arr(i), L + 2) - End If - Else - Split2 Arr(i), " ", S, S2 - End If - If StrComp(sFN, S, vbTextCompare) = 0 Then GetComment = S2: Exit Function - End If -Next -End Function - -Public Function SetComment(FN As String, Comment As String) As Long -On Error Resume Next -Dim S As String, IC As Long, Arr() As String, i As Long, S2 As String -Dim sFN As String, L As Long, f As String, AD As Boolean - -sFN = GetFileNameIN(FN) -S = LoadFile(GetPathOnlyIN(FN) & "descript.ion") -f = FreeFile -Open GetPathOnlyIN(FN) & "descript.ion" For Output As #f -IC = MySplit(Arr(), S) -For i = 1 To IC - If Len(Trim$(Arr(i))) > 0 Then - If Mid$(Arr(i), 1, 1) = Chr$(34) Then - L = InStr(2, Arr(i), Chr$(34)) - S = "": S2 = "" - If L > 2 Then - S = Mid$(Arr(i), 2, L - 2) - S2 = Mid$(Arr(i), L + 2) - End If - Else - Split2 Arr(i), " ", S, S2 - End If - If StrComp(sFN, S, vbTextCompare) = 0 Then - Arr(i) = Chr$(34) & S & Chr$(34) & " " & Comment - AD = True - End If - Print #f, Arr(i) - End If -Next -If Not AD Then - Print #f, Chr$(34) & GetFileNameIN(FN) & Chr$(34) & " " & Comment -End If -Close #f -End Function - -Public Function TTrim(Text As String) As String -Dim B1 As Long, b2 As Long, i As Long, IC As Long, c As Long - -IC = Len(Text) -For B1 = 1 To IC - c = Asc(Mid$(Text, B1, 1)) - If Not ((c = 32) Or (c = 9)) Then GoTo FOR2 -Next -FOR2: - -For b2 = IC To 1 Step -1 - c = Asc(Mid$(Text, b2, 1)) - If Not ((c = 32) Or (c = 9)) Then Exit For -Next -If (B1 > b2) Or (B1 = 0) Or (b2 = 0) Then Exit Function -TTrim = Mid$(Text, B1, (b2 - B1) + 1) -End Function - -Public Function InWork() As Boolean -If CheckFile("C:\.work") = 1 Then InWork = True -End Function - -Public Function MyMkDir(Path As String) As Long -On Error Resume Next -Dim i As Long, IC As Long, Arr() As String, CP As String - -IC = MySplit(Arr(), Path, "\") -For i = 1 To IC - AddToString CP, Arr(i), "\" - MkDir CP -Next -End Function - -Public Function Hex2(ByVal Value As Byte) As String -Hex2 = Hex$(Value) -If Len(Hex2) < 2 Then Hex2 = "0" & Hex2 -End Function - -Public Function LongHex(Text As String) As String -Dim i As Long, IC As Long - -IC = Len(Text) -LongHex = String(IC * 2, " ") -For i = 1 To IC - Mid$(LongHex, i * 2 - 1, 2) = Hex2(Asc(Mid$(Text, i, 1))) -Next -End Function - -Public Function LongUnHex4(Text As String) As String -On Error Resume Next -Dim i As Long, IC As Long, N As Integer, S As String * 2 - -IC = Len(Text) \ 4 -LongUnHex4 = String(IC * 2, " ") -For i = 1 To IC - CopyMemory ByVal S, CInt(Val("&h" & Mid$(Text, i * 4 - 1, 4))), 2 - Mid$(LongUnHex4, i * 2 - 1, 2) = S -Next -End Function - -Public Function LongUnHex(Text As String) As String -Dim i As Long, IC As Long - -IC = Len(Text) \ 2 -LongUnHex = String(IC, " ") -For i = 1 To IC - Mid$(LongUnHex, i, 1) = Chr$(Val(UnHex2(Mid$(Text, i * 2 - 1, 2)))) -Next -End Function - -Public Function MyInStr(Pos As Long, String1 As String, String2 As String) As Long -On Error Resume Next -Dim i As Long, IC As Long, JC As Long - -If Pos < 0 Then Exit Function - -IC = Len(String1) -JC = Len(String2) -If Pos > IC Then Exit Function - -IC = (IC - (JC - 1)) - (Pos - 1) -For i = 1 To IC - If BinaryCompare(Mid$(String1, (Pos - 1) + i, JC), String2) Then MyInStr = (Pos - 1) + i: Exit Function -Next -End Function - -Public Function BinaryCompare(S1 As String, S2 As String) As Boolean -Dim i As Long, IC As Long - -IC = Len(S1) -For i = 1 To IC - If Not Asc(Mid$(S1, i, 1)) = Asc(Mid$(S2, i, 1)) Then Exit Function -Next -BinaryCompare = True -End Function - -Public Function CreateIconFromPBDC(PB As PictureBox) As Long -Dim ICN As Long, INF As ICONINFO, hMask As Long, ms() As Byte - -ReDim ms(0 To PB.ScaleWidth * PB.ScaleHeight / 4) As Byte -hMask = CreateBitmap(PB.ScaleWidth, PB.ScaleHeight, 1, 1, ms(0)) - -INF.fIcon = 1 -INF.hBmMask = hMask -INF.hBmColor = PB.Image.handle - -ICN = CreateIconIndirect(INF) - -DeleteObject hMask -CreateIconFromPBDC = ICN -'If Modify = 0 Then - 'TrayAdd TrayP, Label1.Caption, ICN -'Else -' TrayModify TrayP, Label1.Caption, ICN -'End If - -'DestroyIcon ICN -End Function - -Public Function GetTrayIconW() As Long -GetTrayIconW = GetSystemMetrics(SM_CXSMICON) -End Function - -Public Function GetTrayIconH() As Long -GetTrayIconH = GetSystemMetrics(SM_CYSMICON) -End Function - - -Public Function SetWindowRect(hWnd As Long, wRect As RECT) As Long - - SetWindowRect = SetWindowPos(hWnd, &H0, wRect.Left, wRect.Top, wRect.Right - wRect.Left, wRect.Bottom - wRect.Top, &H10) - -End Function - -Function GetScreen() As RECT - -Dim UZ As RECT, B As Long -B = SystemParametersInfo(SPI_GETWORKAREA, 0, UZ, WM_SETTINGCHANGE) -GetScreen = UZ - -End Function -Public Function IsFullScreen() As Boolean - -Dim g As Long, h As RECT, i As RECT - -g = GetForegroundWindow() -h = GetScreen -Call GetWindowRect(g, i) - -If h.Right - h.Left <= i.Right - i.Left And h.Bottom - h.Top <= i.Bottom - i.Top Then IsFullScreen = True - - -End Function - -Public Sub ResSound(ByVal ResourceId As Integer) - Dim ret As Variant, SoundBuffer As String - 'âîçâðàùàåìàÿ ñòðîêà êîíâåðòèðóåòñÿ ê Óíèêîäó - SoundBuffer = StrConv(LoadResData(ResourceId, "CUSTOM"), vbUnicode) - ret = sndPlaySound(SoundBuffer, 1 Or 2 Or 4) - DoEvents 'Âàæíî: ýòà ôóíêöèÿ íåîáõîäèìà äëÿ àñèíõðîííî èãðàþùåãî çâóêà -End Sub - - -Public Function GetResFile(ByVal ResourceId As Integer) - -Dim i As Integer -Dim temppath As String -Dim slength As Long -temppath = Space(255) -slength = GetTempPath(255, temppath) -temppath = Left(temppath, slength) - -i = FreeFile -SaveFile DirFilterIN(temppath) & "\tmpfile", StrConv(LoadResData(ResourceId, "CUSTOM"), vbUnicode) - -GetResFile = DirFilterIN(temppath) & "\tmpfile" - -End Function - - -Function GetWorkArea() As RECT -Dim r As RECT -Call SystemParametersInfo(SPI_GETWORKAREA, 0, r, 0) -GetWorkArea = r -End Function - -Function SetWorkArea(inArea As RECT) - - Call SystemParametersInfo(SPI_SETWORKAREA, 0, inArea, 0) - -End Function - diff --git a/Tests.Runtime/TestContainer.cs b/Tests.Runtime/TestContainer.cs deleted file mode 100644 index 6e95143..0000000 --- a/Tests.Runtime/TestContainer.cs +++ /dev/null @@ -1,25 +0,0 @@ -using System.IO; -using Rubberduck.Parsing.Grammar; - -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", - @"Public Sub DoSomething() - Debug.Print ""hi from path 1"" - If True Then", - File.ReadAllText("BasicModule(edited).bas") - }; - lexerType = typeof(VBALexer); - parserType = typeof(VBAParser); - parseMethod = "subStmt"; - } - } -} diff --git a/Tests.Runtime/Tests.Runtime.csproj b/Tests.Runtime/Tests.Runtime.csproj deleted file mode 100644 index 602ad43..0000000 --- a/Tests.Runtime/Tests.Runtime.csproj +++ /dev/null @@ -1,29 +0,0 @@ - - - - net472 - 9.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 deleted file mode 100644 index 97d54eb..0000000 --- a/Tests.Shared/CachedValuesFixture.cs +++ /dev/null @@ -1,7 +0,0 @@ -using System; - -namespace ParseTreeVisualizer.Tests { - public class CachedValuesFixture { - public ValueTuple targetsConfigs; - } -} diff --git a/Tests.Shared/Extensions.cs b/Tests.Shared/Extensions.cs deleted file mode 100644 index 6b864d6..0000000 --- a/Tests.Shared/Extensions.cs +++ /dev/null @@ -1,38 +0,0 @@ -using System.Collections.Generic; -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/NullableAttributes.cs b/Tests.Shared/NullableAttributes.cs deleted file mode 100644 index 7b4874f..0000000 --- a/Tests.Shared/NullableAttributes.cs +++ /dev/null @@ -1,81 +0,0 @@ -// 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 deleted file mode 100644 index b51db62..0000000 --- a/Tests.Shared/TestContainer.cs +++ /dev/null @@ -1,57 +0,0 @@ -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 deleted file mode 100644 index 13d5385..0000000 --- a/Tests.Shared/Tests.Shared.projitems +++ /dev/null @@ -1,18 +0,0 @@ - - - - $(MSBuildAllProjects);$(MSBuildThisFileFullPath) - true - 20337a6c-c920-43c8-8b34-665d91eadf89 - - - ParseTreeVisualizer.Tests - - - - - - - - - \ No newline at end of file